JARVIS: asistente de voz local para Linux
Nucleo propio: oye con whisper.cpp, piensa con un modelo de Ollama, habla con Piper, y hace RAG sobre los apuntes del usuario. 100% local, sin cuentas ni claves. Escrito bajo una restriccion dura, 4 GB de VRAM: el cerebro y whisper comparten tarjeta y solo caben porque estan dimensionados para ello. El RAG usa embeddings estaticos con busqueda hibrida; la voz clonada se sirve de una cache de frases. Incluye instalador (install.sh), requisitos, y documentacion del stack, del manejo de root y de las acciones. Los apuntes indexados y el diario NO se incluyen: son privados y el .gitignore los bloquea.
This commit is contained in:
sito
commit
8e4bc8ad94
125 changed files with 25033 additions and 0 deletions
40
.gitignore
vendored
Normal file
40
.gitignore
vendored
Normal file
|
|
@ -0,0 +1,40 @@
|
||||||
|
# Entornos y modelos: se reconstruyen, no se versionan
|
||||||
|
venv/
|
||||||
|
*venv*/
|
||||||
|
__pycache__/
|
||||||
|
*.pyc
|
||||||
|
models/
|
||||||
|
*.onnx
|
||||||
|
*.gguf
|
||||||
|
*.bin
|
||||||
|
*.pt
|
||||||
|
*.ckpt
|
||||||
|
|
||||||
|
# Datos PRIVADOS del usuario: nunca al repositorio
|
||||||
|
# - saber.jsonl y derivados llevan el texto de los apuntes de COFRE
|
||||||
|
# - diario.jsonl es lo que se le dice al asistente por voz
|
||||||
|
# - la voz de referencia y las cachés de audio son personales
|
||||||
|
nucleo/datos/*.jsonl
|
||||||
|
nucleo/datos/saber.jsonl.antes-*
|
||||||
|
nucleo/datos/cache_voz/
|
||||||
|
nucleo/datos/banco.json
|
||||||
|
nucleo/datos/*.log
|
||||||
|
nucleo/datos/informe_rag.txt
|
||||||
|
voz/ref/
|
||||||
|
voz/cache_voz*/
|
||||||
|
voz/dataset/
|
||||||
|
voz/originales/
|
||||||
|
voz/modelos/
|
||||||
|
voz/comparativa/
|
||||||
|
*.wav
|
||||||
|
|
||||||
|
# Excepcion: el catalogo de acciones y su generador SI van (definen que sabe
|
||||||
|
# hacer el asistente, no son datos personales)
|
||||||
|
!nucleo/datos/acciones.json
|
||||||
|
!nucleo/datos/_generar.py
|
||||||
|
|
||||||
|
# Registros y temporales
|
||||||
|
*.log
|
||||||
|
scan.txt
|
||||||
|
PARAR
|
||||||
|
.flatpak-builder/
|
||||||
45
AGENTS.md
Normal file
45
AGENTS.md
Normal file
|
|
@ -0,0 +1,45 @@
|
||||||
|
# JARVIS — mapa del repositorio
|
||||||
|
|
||||||
|
Asistente de voz 100 % local para Linux. Núcleo propio. Este fichero orienta a
|
||||||
|
quien (persona o agente) trabaje en el código.
|
||||||
|
|
||||||
|
**Las rutas relativas van desde la raíz del repositorio.** El núcleo usa rutas
|
||||||
|
relativas a su propia ubicación (`AQUI = dirname(__file__)`); algunos scripts de
|
||||||
|
`config/` y `voz/` todavía asumen rutas absolutas del entorno del autor y habría
|
||||||
|
que hacerlas configurables.
|
||||||
|
|
||||||
|
## El flujo
|
||||||
|
|
||||||
|
oír → pensar → hacer → hablar
|
||||||
|
|
||||||
|
`nucleo/jarvis.py` es el bucle. Oye con whisper (`oido/`), decide con el modelo
|
||||||
|
(`cerebro/`), ejecuta con las manos (`manos/`) o contesta, y habla (`boca/`). El
|
||||||
|
panel (`cara/`) muestra todo en vivo.
|
||||||
|
|
||||||
|
## Carpetas
|
||||||
|
|
||||||
|
nucleo/
|
||||||
|
jarvis.py la entrada; arranca.sh lo lanza
|
||||||
|
oido/ whisper.cpp: captura, palabra de activación, transcripción
|
||||||
|
cerebro/ ollama, tool-calling, y el RAG (pasivo + agéntico)
|
||||||
|
boca/ Piper. voz.py fija la voz por defecto
|
||||||
|
manos/ las acciones, el diario, el sudo, la fonética
|
||||||
|
cara/ el panel web y su servidor
|
||||||
|
saber/ el RAG: indexa, busca, glosario; enriquece/ lo mejora
|
||||||
|
datos/ acciones.json (el catálogo). El resto es privado (.gitignore)
|
||||||
|
pruebas/ la suite del núcleo
|
||||||
|
|
||||||
|
config/ configuración: modelo (Modelfile), voz, whisper CUDA
|
||||||
|
voz/ clonado de voz con XTTS y caché de frases
|
||||||
|
entrena/ fine-tuning con QLoRA
|
||||||
|
|
||||||
|
## Dos cosas que ahorran errores
|
||||||
|
|
||||||
|
- **La gráfica es pequeña (4 GB) y el cerebro y whisper compiten por ella.**
|
||||||
|
Antes de tocar el dimensionado, mirar el presupuesto de VRAM del README.
|
||||||
|
- **Los datos del usuario no se versionan.** `saber.jsonl`, `diario.jsonl` y las
|
||||||
|
cachés de voz son privados: el `.gitignore` los bloquea. Ver PRIVACIDAD.md.
|
||||||
|
|
||||||
|
## Estilo
|
||||||
|
|
||||||
|
Registro técnico y conciso. Los commits describen el porqué, no solo el qué.
|
||||||
51
PRIVACIDAD.md
Normal file
51
PRIVACIDAD.md
Normal file
|
|
@ -0,0 +1,51 @@
|
||||||
|
# Privacidad
|
||||||
|
|
||||||
|
La premisa del proyecto es que nada sale de la máquina. No es un eslogan: se
|
||||||
|
verifica, y este documento dice qué es local, qué podría salir y qué se ha
|
||||||
|
dejado deliberadamente fuera de este repositorio.
|
||||||
|
|
||||||
|
## Qué es local
|
||||||
|
|
||||||
|
| Pieza | Dónde corre |
|
||||||
|
|---|---|
|
||||||
|
| Cerebro (modelo) | Ollama en `127.0.0.1:11434` |
|
||||||
|
| Escucha (STT) | whisper.cpp, en la propia máquina |
|
||||||
|
| Voz (TTS) | Piper / XTTS, en la propia máquina |
|
||||||
|
| Memoria de conversación | ficheros locales |
|
||||||
|
| RAG | índice local sobre apuntes locales |
|
||||||
|
|
||||||
|
Ninguna de estas piezas necesita una cuenta ni una clave. El asistente funciona
|
||||||
|
con la máquina desconectada de internet.
|
||||||
|
|
||||||
|
## Qué puede salir, y no es un fallo
|
||||||
|
|
||||||
|
- **La búsqueda web**, solo si el modelo decide usarla para una pregunta que lo
|
||||||
|
pide. Es una herramienta que se invoca, no una fuga de fondo, y se avisa.
|
||||||
|
|
||||||
|
Fuera de eso, no hay tráfico saliente durante el uso normal.
|
||||||
|
|
||||||
|
## Qué NO está en este repositorio, a propósito
|
||||||
|
|
||||||
|
Este código es público; los datos del usuario no. El `.gitignore` bloquea, y
|
||||||
|
nunca se deben añadir:
|
||||||
|
|
||||||
|
- **`nucleo/datos/saber.jsonl`** y sus derivados (`cosecha.jsonl`,
|
||||||
|
`sintesis.jsonl`): contienen el TEXTO de los apuntes indexados. Publicarlos
|
||||||
|
publicaría los apuntes.
|
||||||
|
- **`nucleo/datos/diario.jsonl`**: es lo que el usuario le ha dicho al asistente
|
||||||
|
por voz.
|
||||||
|
- **`voz/ref/`** y las cachés de audio: la voz de referencia y las frases
|
||||||
|
sintetizadas son personales.
|
||||||
|
- **Entornos, modelos y datasets**: se reconstruyen; no son código.
|
||||||
|
|
||||||
|
Lo único de `nucleo/datos/` que sí va es `acciones.json` (el catálogo de lo que
|
||||||
|
el asistente sabe hacer) y su generador: definen capacidades, no datos.
|
||||||
|
|
||||||
|
## Cómo comprobarlo
|
||||||
|
|
||||||
|
- Que nada nuestro escuche fuera de loopback:
|
||||||
|
`ss -ltnp | grep -vE '127\.0\.0\.1|\[::1\]'`
|
||||||
|
- Que el cerebro apunta a local: revisar el endpoint en `nucleo/cerebro/`.
|
||||||
|
- Que no hay claves en el repo: no hay ningún fichero de credenciales; el
|
||||||
|
manejador de sudo (`nucleo/manos/sudo_root.py`) guarda la contraseña solo en
|
||||||
|
memoria durante la sesión y la borra al terminar.
|
||||||
163
README.md
Normal file
163
README.md
Normal file
|
|
@ -0,0 +1,163 @@
|
||||||
|
# JARVIS
|
||||||
|
|
||||||
|
Asistente de voz **100 % local** para Linux. Ni el micrófono, ni las
|
||||||
|
conversaciones, ni el modelo salen de la máquina. Sin cuentas, sin claves, sin
|
||||||
|
nube. Núcleo propio, escrito para caber en una tarjeta pequeña (NVIDIA T1200 de
|
||||||
|
4 GB) y hacer lo que se le pide por voz, en castellano.
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
```
|
||||||
|
┌───────────────────────────┐
|
||||||
|
micrófono ─────>│ OÍDO whisper.cpp CUDA │ STT castellano
|
||||||
|
│ sm_75 · small/GPU │ ~930 ms régimen
|
||||||
|
└─────────────┬─────────────┘
|
||||||
|
v
|
||||||
|
apuntes propios ──> ┌───────────┐ ┌─────────────────────────┐
|
||||||
|
(RAG) │ SABER │─>│ CEREBRO ollama │
|
||||||
|
│ model2vec │ │ qwen3.5:4b · tool-call │
|
||||||
|
│ +híbrido │ │ + RAG pasivo Y agéntico │
|
||||||
|
└───────────┘ └─────────────┬───────────┘
|
||||||
|
v
|
||||||
|
┌───────────────┐ ┌──────────────────────┐
|
||||||
|
altavoz <───────────│ BOCA Piper │<─│ MANOS │
|
||||||
|
│ / voz clonada│ │ acciones + shell │
|
||||||
|
└───────────────┘ └──────────────────────┘
|
||||||
|
│
|
||||||
|
┌───────────┴───────────────────────────┐
|
||||||
|
│ CARA panel web · WebSocket · reactor │
|
||||||
|
└────────────────────────────────────────┘
|
||||||
|
todo en 127.0.0.1 · 0 llamadas a la nube
|
||||||
|
```
|
||||||
|
|
||||||
|
<!-- Captura del panel: añadir docs/panel.png y descomentar
|
||||||
|
|
||||||
|
-->
|
||||||
|
|
||||||
|
## El stack
|
||||||
|
|
||||||
|
| Capa | Pieza | Papel |
|
||||||
|
|---|---|---|
|
||||||
|
| Oír | whisper.cpp (CUDA, sm_75) | STT en castellano, en la GPU |
|
||||||
|
| Pensar | Ollama · `qwen3.5:4b` | el cerebro, con tool-calling |
|
||||||
|
| Saber | model2vec + búsqueda híbrida | RAG sobre los apuntes del usuario |
|
||||||
|
| Hablar | Piper (o voz clonada con XTTS) | TTS local |
|
||||||
|
| Cara | panel web · WebSocket · Canvas | el HUD, con el reactor y las métricas |
|
||||||
|
| Manos | catálogo de acciones + shell | lo que ejecuta en la máquina |
|
||||||
|
|
||||||
|
Todo corre en `127.0.0.1`. No hay ninguna llamada a la nube en el uso normal; lo
|
||||||
|
único que puede salir es una búsqueda web si el modelo decide usarla, y se avisa.
|
||||||
|
|
||||||
|
## Requisitos de hardware
|
||||||
|
|
||||||
|
Referencia (el equipo del autor):
|
||||||
|
|
||||||
|
| | |
|
||||||
|
|---|---|
|
||||||
|
| GPU | NVIDIA T1200, **4 GB VRAM**, Turing (sm_75) |
|
||||||
|
| RAM | 62 GB |
|
||||||
|
| SO | Debian 12, GNOME sobre X11, PipeWire |
|
||||||
|
|
||||||
|
La restricción que manda es la VRAM. El presupuesto, medido:
|
||||||
|
|
||||||
|
```
|
||||||
|
┌──────────────────────────────────┬──────────┬───────────────────────┐
|
||||||
|
│ COMPONENTE │ VRAM │ NOTA │
|
||||||
|
├──────────────────────────────────┼──────────┼───────────────────────┤
|
||||||
|
│ qwen3.5:4b (24/32 capas en GPU) │ 2177 MiB │ el cerebro │
|
||||||
|
│ whisper small (PICO de la trans- │ 839 MiB │ el pico, no el reposo:│
|
||||||
|
│ cripción) │ │ ahí estuvo el OOM │
|
||||||
|
│ ── suma ── │ 3016 MiB │ cabe, con margen justo│
|
||||||
|
└──────────────────────────────────┴──────────┴───────────────────────┘
|
||||||
|
```
|
||||||
|
|
||||||
|
Corre en menos con un modelo más pequeño; con más VRAM, sobra sitio.
|
||||||
|
|
||||||
|
## Instalación
|
||||||
|
|
||||||
|
Necesita, en la máquina: [Ollama](https://ollama.com), whisper.cpp compilado con
|
||||||
|
CUDA (ver [`config/README_whisper_gpu.md`](config/README_whisper_gpu.md)) y
|
||||||
|
[Piper](https://github.com/rhasspy/piper).
|
||||||
|
|
||||||
|
```bash
|
||||||
|
git clone https://gitea.laenre.net/hacklab/JARVIS.git
|
||||||
|
cd JARVIS
|
||||||
|
./install.sh # comprueba servicios, crea el venv y el modelo de Ollama
|
||||||
|
```
|
||||||
|
|
||||||
|
`install.sh` no descarga modelos pesados ni toca el sistema sin avisar: solo
|
||||||
|
prepara el entorno de Python y crea `qwen3.5:4b-jarvis` a partir del `Modelfile`.
|
||||||
|
|
||||||
|
Después:
|
||||||
|
|
||||||
|
```bash
|
||||||
|
./nucleo/saber/indexa.py # (opcional) indexa tus apuntes para el RAG
|
||||||
|
./nucleo/arranca.sh # el asistente y el panel, en 127.0.0.1
|
||||||
|
```
|
||||||
|
|
||||||
|
## Qué le puedes pedir
|
||||||
|
|
||||||
|
Habla en castellano, natural. **150 acciones** en el catálogo, agrupadas:
|
||||||
|
|
||||||
|
| Grupo | Nº | Ejemplos |
|
||||||
|
|---|---|---|
|
||||||
|
| sistema | 59 | "cuánto espacio queda", "la memoria", "la carga de CPU", "la temperatura" |
|
||||||
|
| firefox | 54 | "abre el Gmail", "abre YouTube", "abre el GitHub", "abre Maps" |
|
||||||
|
| ventanas | 12 | "manda la ventana a la izquierda", "maximiza", "centra la ventana" |
|
||||||
|
| ficheros | 11 | "busca un fichero llamado…", "lee el fichero…", "cuánto ocupa la carpeta…" |
|
||||||
|
| pentest | 8 | "escanea la red", "los puertos del host…", "resuelve el dominio…", "el whois de…" |
|
||||||
|
| oasis | 6 | "está corriendo Oasis", "cuántas conexiones tiene" |
|
||||||
|
|
||||||
|
Si lo que pides no está en el catálogo, el modelo lo resuelve con un **comando de
|
||||||
|
shell** (de solo lectura por defecto). Y si pregunta *cómo* se hace algo técnico,
|
||||||
|
puede **buscar en tus apuntes** (RAG) antes de responder, para dar el comando que
|
||||||
|
ya has probado en vez de inventarlo.
|
||||||
|
|
||||||
|
## Órdenes con root
|
||||||
|
|
||||||
|
Algunas acciones necesitan `sudo`. El manejo es explícito y con límites, no un
|
||||||
|
"root para siempre":
|
||||||
|
|
||||||
|
- La contraseña **nunca se escribe en disco**. Vive en memoria del proceso solo
|
||||||
|
si activas el permiso de sesión, y se pasa a `sudo -S` por la entrada estándar.
|
||||||
|
- El permiso de sesión **caduca a los 15 minutos** de la última orden, y también
|
||||||
|
al cerrar el panel.
|
||||||
|
- **Cada** orden con root muestra su comando exacto en un diálogo antes de
|
||||||
|
ejecutarlo. El permiso de sesión solo ahorra re-teclear la contraseña; nunca
|
||||||
|
salta el ver y aprobar. **La voz no puede autoaprobar root.**
|
||||||
|
|
||||||
|
Con el candado echado, el asistente no obedece órdenes que toquen el sistema:
|
||||||
|
las pide desbloquear primero.
|
||||||
|
|
||||||
|
## Privacidad
|
||||||
|
|
||||||
|
Es la premisa, y se verifica. Ver [PRIVACIDAD.md](PRIVACIDAD.md). Este
|
||||||
|
repositorio **no incluye** los apuntes indexados ni el diario de conversación:
|
||||||
|
son del usuario, y el `.gitignore` los bloquea.
|
||||||
|
|
||||||
|
## Estructura
|
||||||
|
|
||||||
|
```
|
||||||
|
nucleo/ el asistente (oido, cerebro, boca, manos, cara, saber)
|
||||||
|
config/ configuración: modelo, voz, whisper CUDA
|
||||||
|
voz/ clonado de voz con XTTS y caché de frases
|
||||||
|
entrena/ fine-tuning con QLoRA
|
||||||
|
install.sh el instalador
|
||||||
|
```
|
||||||
|
|
||||||
|
## Estado y limitaciones
|
||||||
|
|
||||||
|
Proyecto en desarrollo. Rugosidades conocidas: varios scripts de `config/` y
|
||||||
|
`voz/` asumen rutas absolutas del entorno del autor (`~/COFRE/...`) y habría que
|
||||||
|
hacerlas configurables; el fine-tuning de `entrena/` está pendiente de un ajuste
|
||||||
|
para modelos multimodales.
|
||||||
|
|
||||||
|
## Licencia
|
||||||
|
|
||||||
|
Por decidir por el autor. El núcleo es código propio, no derivado.
|
||||||
30
config/README_whisper_gpu.md
Normal file
30
config/README_whisper_gpu.md
Normal file
|
|
@ -0,0 +1,30 @@
|
||||||
|
# Whisper small en GPU
|
||||||
|
|
||||||
|
El reconocimiento pasa del modelo `base` en CPU al `small` en GPU. Medido:
|
||||||
|
|
||||||
|
| | acierto | latencia (régimen) |
|
||||||
|
|---|---|---|
|
||||||
|
| base · CPU | 80 % | 928 ms |
|
||||||
|
| small · GPU | **93 %** | **~930 ms** |
|
||||||
|
|
||||||
|
Misma velocidad, +13 puntos de acierto. `small` ocupa 757 MiB en la T1200 y
|
||||||
|
coexiste con el modelo grande de Ollama (2901/3717 MiB con los dos cargados).
|
||||||
|
|
||||||
|
## Cómo está montado
|
||||||
|
|
||||||
|
- whisper.cpp compilado con CUDA (sm_75) en `voz/whisper-cuda/` (no versionado;
|
||||||
|
se reconstruye con `cmake -B build -DGGML_CUDA=ON -DCMAKE_CUDA_ARCHITECTURES=75`).
|
||||||
|
- Envoltorio `~/.local/bin/whisper-server` (copia de referencia en
|
||||||
|
`config/whisper-server-cuda.sh`): fija `LD_LIBRARY_PATH` a las libs de CUDA y
|
||||||
|
llama al binario. Está en el PATH del host, que es donde Newelle lo busca.
|
||||||
|
- Ajustes de Newelle: `stt-settings.whispercpp = {model: small,
|
||||||
|
use_system_server: true}`. El handler arranca el servidor por
|
||||||
|
`flatpak-spawn --host whisper-server` y le pega las peticiones.
|
||||||
|
|
||||||
|
## Lo único a saber
|
||||||
|
|
||||||
|
La PRIMERA transcripción de cada sesión tarda ~4 s: es el arranque del servidor
|
||||||
|
(cargar el modelo a la GPU). A partir de ahí, ~930 ms. El servidor se queda
|
||||||
|
vivo mientras la app corre.
|
||||||
|
|
||||||
|
Para volver a CPU: `use_system_server: false` y `model: base` en los ajustes.
|
||||||
53
config/ampliar_swap.sh
Normal file
53
config/ampliar_swap.sh
Normal file
|
|
@ -0,0 +1,53 @@
|
||||||
|
#!/usr/bin/env bash
|
||||||
|
# Amplia la swap en caliente, sin reiniciar y sin tocar particiones.
|
||||||
|
#
|
||||||
|
# Por que: el portatil tiene 62 GB de RAM y 976 MiB de swap en la particion
|
||||||
|
# nvme0n1p3. Ese reparto es de una maquina con 2 GB de RAM, no con 62. La swap
|
||||||
|
# se llena (96% medido) y aunque hoy no cause nada —comprobado: si=4 so=0 KB/s,
|
||||||
|
# 43 GB de RAM disponible, ninguna fuga— no queda colchon para cuando algo pida
|
||||||
|
# memoria de golpe.
|
||||||
|
#
|
||||||
|
# Lo que NO arregla: nada de lo que se notaba. La pantalla que pedia contraseña
|
||||||
|
# era el candado de JARVIS, no el sistema. Esto es higiene, no una reparacion.
|
||||||
|
#
|
||||||
|
# Se ejecuta con sudo y no hace falta reiniciar: `swapon` activa el fichero al
|
||||||
|
# momento y la linea del fstab solo sirve para el proximo arranque.
|
||||||
|
#
|
||||||
|
# sudo bash ampliar_swap.sh [tamaño] # por defecto 16G
|
||||||
|
set -euo pipefail
|
||||||
|
|
||||||
|
TAM=${1:-16G}
|
||||||
|
FICHERO=/swapfile
|
||||||
|
|
||||||
|
[ "$(id -u)" -eq 0 ] || { echo "hay que ejecutarlo con sudo" >&2; exit 1; }
|
||||||
|
|
||||||
|
if swapon --show=NAME --noheadings 2>/dev/null | grep -qx "$FICHERO"; then
|
||||||
|
echo "$FICHERO ya esta activo; nada que hacer."
|
||||||
|
swapon --show
|
||||||
|
exit 0
|
||||||
|
fi
|
||||||
|
|
||||||
|
echo "1. creando $FICHERO de $TAM"
|
||||||
|
# fallocate va bien en ext4; en btrfs haria falta otra receta (chattr +C y
|
||||||
|
# sin compresion), pero la raiz de esta maquina es ext4.
|
||||||
|
fallocate -l "$TAM" "$FICHERO" 2>/dev/null || dd if=/dev/zero of="$FICHERO" bs=1M count=$((${TAM%G} * 1024)) status=none
|
||||||
|
chmod 600 "$FICHERO" # solo root: si no, mkswap se niega y con razon
|
||||||
|
|
||||||
|
echo "2. formateando"
|
||||||
|
mkswap "$FICHERO" >/dev/null
|
||||||
|
|
||||||
|
echo "3. activando (aqui ya esta funcionando, sin reiniciar)"
|
||||||
|
swapon "$FICHERO"
|
||||||
|
|
||||||
|
echo "4. dejandolo puesto para el proximo arranque"
|
||||||
|
grep -q "^$FICHERO " /etc/fstab || echo "$FICHERO none swap sw 0 0" >> /etc/fstab
|
||||||
|
|
||||||
|
# Con 62 GB de RAM no tiene sentido apartar paginas al disco con la alegria de
|
||||||
|
# swappiness=60: se baja a 10 para que la swap sea un seguro y no una costumbre.
|
||||||
|
echo "5. bajando swappiness de $(cat /proc/sys/vm/swappiness) a 10"
|
||||||
|
sysctl -q vm.swappiness=10
|
||||||
|
echo "vm.swappiness=10" > /etc/sysctl.d/99-jarvis-swappiness.conf
|
||||||
|
|
||||||
|
echo
|
||||||
|
swapon --show
|
||||||
|
free -h | head -3
|
||||||
148
config/aprender.py
Normal file
148
config/aprender.py
Normal file
|
|
@ -0,0 +1,148 @@
|
||||||
|
#!/usr/bin/env python3
|
||||||
|
"""Enseña acciones nuevas a partir de lo que no entendió.
|
||||||
|
|
||||||
|
python3 ~/COFRE/CODERS/JARVIS/config/aprender.py
|
||||||
|
|
||||||
|
Cada vez que dices algo que no encaja con ninguna accion, el panel lo anota en
|
||||||
|
config/jarvis-sin-accion.jsonl. Esto lo lee, agrupa lo repetido y pregunta a
|
||||||
|
que accion pertenece cada frase; lo que decidas se escribe como alias en
|
||||||
|
config/jarvis-acciones.json, que el catalogo carga ANTES que el del paquete.
|
||||||
|
|
||||||
|
Por que asi y no entrenando un modelo: los fallos del reconocedor son
|
||||||
|
sistematicos, no aleatorios. "abre el correo" se oye "a ver el correo" siempre,
|
||||||
|
no una de cada diez veces. Un alias lo arregla del todo, se lee, se borra si
|
||||||
|
molesta y no cuesta un milisegundo. Reentrenar costaria horas para acertar
|
||||||
|
"casi siempre".
|
||||||
|
"""
|
||||||
|
import json
|
||||||
|
import os
|
||||||
|
import sys
|
||||||
|
from collections import Counter
|
||||||
|
|
||||||
|
CONFIG = os.path.expanduser("~/.var/app/io.github.qwersyk.Newelle/config")
|
||||||
|
REGISTRO = os.path.join(CONFIG, "jarvis-sin-accion.jsonl")
|
||||||
|
PROPIO = os.path.join(CONFIG, "jarvis-acciones.json")
|
||||||
|
PAQUETE = os.path.expanduser(
|
||||||
|
"~/.local/share/flatpak/app/io.github.qwersyk.Newelle/x86_64/master/"
|
||||||
|
"active/files/share/newelle/acciones/acciones.json")
|
||||||
|
|
||||||
|
|
||||||
|
def carga_catalogo():
|
||||||
|
acciones = {}
|
||||||
|
for ruta in (PAQUETE, PROPIO):
|
||||||
|
try:
|
||||||
|
with open(ruta) as f:
|
||||||
|
for a in json.load(f).get("acciones", []):
|
||||||
|
acciones.setdefault(a["id"], a)
|
||||||
|
except (OSError, json.JSONDecodeError):
|
||||||
|
pass
|
||||||
|
return acciones
|
||||||
|
|
||||||
|
|
||||||
|
def carga_fallos():
|
||||||
|
"""Las frases sin accion, agrupadas por veces que se han dicho."""
|
||||||
|
cuenta = Counter()
|
||||||
|
try:
|
||||||
|
with open(REGISTRO) as f:
|
||||||
|
for linea in f:
|
||||||
|
try:
|
||||||
|
texto = json.loads(linea).get("texto", "").strip()
|
||||||
|
except json.JSONDecodeError:
|
||||||
|
continue
|
||||||
|
if texto:
|
||||||
|
cuenta[texto] += 1
|
||||||
|
except OSError:
|
||||||
|
pass
|
||||||
|
return cuenta
|
||||||
|
|
||||||
|
|
||||||
|
def guarda_alias(nuevos):
|
||||||
|
"""Añade los alias al catalogo propio, respetando lo que ya hubiera."""
|
||||||
|
try:
|
||||||
|
with open(PROPIO) as f:
|
||||||
|
propio = json.load(f)
|
||||||
|
except (OSError, json.JSONDecodeError):
|
||||||
|
propio = {"version": 1, "acciones": []}
|
||||||
|
|
||||||
|
porid = {a["id"]: a for a in propio.get("acciones", [])}
|
||||||
|
catalogo = carga_catalogo()
|
||||||
|
|
||||||
|
for ident, frases in nuevos.items():
|
||||||
|
if ident in porid:
|
||||||
|
entrada = porid[ident]
|
||||||
|
else:
|
||||||
|
# se copia la del paquete entera: el catalogo propio se carga antes
|
||||||
|
# y sustituye a la original, asi que tiene que traer su comando
|
||||||
|
entrada = dict(catalogo[ident])
|
||||||
|
porid[ident] = entrada
|
||||||
|
propio.setdefault("acciones", []).append(entrada)
|
||||||
|
for f in frases:
|
||||||
|
if f not in entrada["frases"]:
|
||||||
|
entrada["frases"].append(f)
|
||||||
|
|
||||||
|
with open(PROPIO, "w") as f:
|
||||||
|
json.dump(propio, f, indent=2, ensure_ascii=False)
|
||||||
|
return PROPIO
|
||||||
|
|
||||||
|
|
||||||
|
def main():
|
||||||
|
fallos = carga_fallos()
|
||||||
|
if not fallos:
|
||||||
|
print("No hay nada sin entender todavia.")
|
||||||
|
print(f"Se anota solo en {REGISTRO}")
|
||||||
|
return 0
|
||||||
|
|
||||||
|
catalogo = carga_catalogo()
|
||||||
|
ids = sorted(catalogo)
|
||||||
|
print(f"{len(fallos)} frases distintas no encajaron con ninguna accion.\n")
|
||||||
|
|
||||||
|
nuevos = {}
|
||||||
|
for texto, veces in fallos.most_common():
|
||||||
|
print(f' "{texto}" ({veces} {"vez" if veces == 1 else "veces"})')
|
||||||
|
print(" escribe el id de la accion, 'l' para listarlos, "
|
||||||
|
"Enter para saltar, 'q' para terminar")
|
||||||
|
try:
|
||||||
|
resp = input(" > ").strip()
|
||||||
|
except (EOFError, KeyboardInterrupt):
|
||||||
|
print()
|
||||||
|
break
|
||||||
|
|
||||||
|
if resp == "q":
|
||||||
|
break
|
||||||
|
if resp == "l":
|
||||||
|
for i, ident in enumerate(ids):
|
||||||
|
print(f" {ident:<24}", end="\n" if i % 3 == 2 else "")
|
||||||
|
print()
|
||||||
|
try:
|
||||||
|
resp = input(" > ").strip()
|
||||||
|
except (EOFError, KeyboardInterrupt):
|
||||||
|
break
|
||||||
|
if not resp:
|
||||||
|
continue
|
||||||
|
if resp not in catalogo:
|
||||||
|
print(f" '{resp}' no existe, saltada")
|
||||||
|
continue
|
||||||
|
|
||||||
|
nuevos.setdefault(resp, []).append(texto)
|
||||||
|
print(f" anotada como alias de {resp}")
|
||||||
|
|
||||||
|
if not nuevos:
|
||||||
|
print("\nNada que guardar.")
|
||||||
|
return 0
|
||||||
|
|
||||||
|
ruta = guarda_alias(nuevos)
|
||||||
|
total = sum(len(v) for v in nuevos.values())
|
||||||
|
print(f"\n{total} alias guardados en {ruta}")
|
||||||
|
print("Se aplican al abrir la pestaña JARVIS otra vez.")
|
||||||
|
|
||||||
|
if input("¿Vaciar el registro de frases no entendidas? [s/N] ").strip().lower() == "s":
|
||||||
|
try:
|
||||||
|
os.remove(REGISTRO)
|
||||||
|
print("registro vaciado")
|
||||||
|
except OSError as e:
|
||||||
|
print(f"no se pudo vaciar: {e}")
|
||||||
|
return 0
|
||||||
|
|
||||||
|
|
||||||
|
if __name__ == "__main__":
|
||||||
|
sys.exit(main())
|
||||||
65
config/apuntar_modelo_jarvis.py
Normal file
65
config/apuntar_modelo_jarvis.py
Normal file
|
|
@ -0,0 +1,65 @@
|
||||||
|
#!/usr/bin/env python3
|
||||||
|
"""Apunta el cerebro de Newelle al modelo qwen3.5:4b-jarvis.
|
||||||
|
|
||||||
|
Es la variante con num_gpu 24 (ver qwen3.5-4b-jarvis.Modelfile): deja 1540 MiB
|
||||||
|
libres en la tarjeta para que whisper pueda transcribir sin morir de OOM.
|
||||||
|
|
||||||
|
Toca solo la clave llm-settings, y dentro solo el bloque "ollama": el modelo
|
||||||
|
elegido, la lista de modelos y la biblioteca que se ve en la interfaz.
|
||||||
|
"""
|
||||||
|
import json
|
||||||
|
import subprocess
|
||||||
|
import sys
|
||||||
|
|
||||||
|
APP = "io.github.qwersyk.Newelle"
|
||||||
|
RAMA = "master"
|
||||||
|
MODELO = "qwen3.5:4b-jarvis"
|
||||||
|
|
||||||
|
GSET = ["flatpak", "run", f"--command=gsettings", f"{APP}//{RAMA}"]
|
||||||
|
|
||||||
|
|
||||||
|
def leer(clave):
|
||||||
|
out = subprocess.check_output(GSET + ["get", APP, clave], text=True).strip()
|
||||||
|
# gsettings devuelve el string entre comillas simples, con \\ escapados
|
||||||
|
return json.loads(out[1:-1].replace("\\\\", "\\").replace("\\'", "'"))
|
||||||
|
|
||||||
|
|
||||||
|
def escribir(clave, valor):
|
||||||
|
subprocess.check_call(GSET + ["set", APP, clave, json.dumps(valor)])
|
||||||
|
|
||||||
|
|
||||||
|
def main():
|
||||||
|
ajustes = leer("llm-settings")
|
||||||
|
ollama = ajustes.setdefault("ollama", {})
|
||||||
|
|
||||||
|
anterior = ollama.get("model")
|
||||||
|
if anterior == MODELO:
|
||||||
|
print(f"ya apuntaba a {MODELO}; nada que hacer.")
|
||||||
|
return 0
|
||||||
|
|
||||||
|
ollama["model"] = MODELO
|
||||||
|
|
||||||
|
# la lista de modelos del desplegable: pares [clave, titulo]
|
||||||
|
modelos = json.loads(ollama.get("models", "[]"))
|
||||||
|
if not any(m[0] == MODELO for m in modelos):
|
||||||
|
modelos.insert(0, [MODELO, MODELO])
|
||||||
|
ollama["models"] = json.dumps(modelos)
|
||||||
|
|
||||||
|
# la biblioteca que pinta la interfaz, para que salga con descripcion
|
||||||
|
biblioteca = ollama.get("model-library", [])
|
||||||
|
if not any(m.get("key") == MODELO for m in biblioteca):
|
||||||
|
biblioteca.insert(0, {
|
||||||
|
"key": MODELO,
|
||||||
|
"title": "qwen3.5 4b (JARVIS)",
|
||||||
|
"description": "qwen3.5:4b con 24 de 32 capas en GPU, para dejar "
|
||||||
|
"sitio a whisper en la tarjeta de 4 GB.",
|
||||||
|
})
|
||||||
|
ollama["model-library"] = biblioteca
|
||||||
|
|
||||||
|
escribir("llm-settings", ajustes)
|
||||||
|
print(f"cerebro: {anterior} -> {MODELO}")
|
||||||
|
return 0
|
||||||
|
|
||||||
|
|
||||||
|
if __name__ == "__main__":
|
||||||
|
sys.exit(main())
|
||||||
464
config/autoescuela.py
Executable file
464
config/autoescuela.py
Executable file
|
|
@ -0,0 +1,464 @@
|
||||||
|
#!/usr/bin/env python3
|
||||||
|
"""Dos JARVIS hablando: uno examina, el otro ejecuta, el primero corrige.
|
||||||
|
|
||||||
|
python3 ~/COFRE/CODERS/JARVIS/config/autoescuela.py # una tanda
|
||||||
|
python3 ~/COFRE/CODERS/JARVIS/config/autoescuela.py --horas 6 # toda la noche
|
||||||
|
python3 ~/COFRE/CODERS/JARVIS/config/autoescuela.py --aplicar # guardar mejoras
|
||||||
|
|
||||||
|
La idea. Los bucles que teniamos probaban trozos: mejora_nocturna comprobaba
|
||||||
|
solo si la frase llega a la accion; probar_acciones, solo si la accion corre.
|
||||||
|
Esto los junta en una conversacion de punta a punta y por AUDIO:
|
||||||
|
|
||||||
|
Examinador -> dice una tarea en voz alta (Piper), con ruido y sala
|
||||||
|
Jarvis -> la oye (Whisper), decide que accion es, la ejecuta,
|
||||||
|
y contesta en voz alta
|
||||||
|
Examinador -> comprueba tres cosas:
|
||||||
|
1. ¿oyo la tarea correcta? (reconocimiento)
|
||||||
|
2. ¿hizo la accion que tocaba? (emparejamiento)
|
||||||
|
3. ¿el resultado tiene sentido? (ejecucion y respuesta)
|
||||||
|
y pone nota
|
||||||
|
|
||||||
|
Lo que se ejecuta de verdad: solo lo de solo lectura. Lo que abre cosas, apaga
|
||||||
|
o necesita root se comprueba hasta el emparejamiento, sin lanzarlo —una
|
||||||
|
autoescuela no deberia apagarte la pantalla ni pedir tu contraseña de noche.
|
||||||
|
|
||||||
|
Lo que aprende: los fallos se separan por tipo. Un fallo de reconocimiento
|
||||||
|
propone un alias (con el mismo filtro seguro de mejora_nocturna: sistematico,
|
||||||
|
sin ambiguedad, conserva palabra clave). Un fallo de ejecucion o de respuesta
|
||||||
|
se ANOTA para arreglarlo a mano —eso no se toca solo, que es codigo—.
|
||||||
|
|
||||||
|
Escenarios: casi todos son de un turno (una tarea, una respuesta), sacados del
|
||||||
|
catalogo. Unos pocos son de varios turnos para probar lo que tiene estado:
|
||||||
|
buscar -> "abre el segundo" -> "busca dentro X". Y hay charla que NO debe
|
||||||
|
disparar ninguna accion, como control negativo.
|
||||||
|
"""
|
||||||
|
import argparse
|
||||||
|
import importlib.util
|
||||||
|
import json
|
||||||
|
import os
|
||||||
|
import random
|
||||||
|
import re
|
||||||
|
import shlex
|
||||||
|
import shutil
|
||||||
|
import subprocess
|
||||||
|
import sys
|
||||||
|
import tempfile
|
||||||
|
import time
|
||||||
|
from collections import defaultdict
|
||||||
|
|
||||||
|
CASA = os.path.expanduser("~")
|
||||||
|
JARVIS = os.path.join(CASA, "COFRE/CODERS/JARVIS")
|
||||||
|
CONFIG = os.path.join(CASA, ".var/app/io.github.qwersyk.Newelle/config")
|
||||||
|
APP = "io.github.qwersyk.Newelle//master"
|
||||||
|
|
||||||
|
PIPER = os.path.join(JARVIS, "voz/piper/piper")
|
||||||
|
MODELOS_VOZ = os.path.join(JARVIS, "voz/modelos")
|
||||||
|
WHISPER = os.path.join(CONFIG, "models/whisper/whisper.cpp/build/bin/whisper-cli")
|
||||||
|
MODELOS_STT = os.path.join(CONFIG, "models/whisper/whisper.cpp/models")
|
||||||
|
|
||||||
|
CATALOGO = os.path.expanduser(
|
||||||
|
"~/.local/share/flatpak/app/io.github.qwersyk.Newelle/x86_64/master/"
|
||||||
|
"active/files/share/newelle/acciones/acciones.json")
|
||||||
|
CATALOGO_FUENTE = os.path.join(JARVIS, "newelle/data/acciones/acciones.json")
|
||||||
|
PROPIO = os.path.join(CONFIG, "jarvis-acciones.json")
|
||||||
|
MOTOR = os.path.join(JARVIS, "newelle/src/utility/acciones.py")
|
||||||
|
SELECCION = os.path.join(JARVIS, "newelle/src/utility/seleccion.py")
|
||||||
|
|
||||||
|
SALA = os.path.join(JARVIS, "muestras/autoescuela")
|
||||||
|
DIALOGO = os.path.join(SALA, "dialogo.log")
|
||||||
|
INFORME = os.path.join(SALA, "informe.json")
|
||||||
|
WAVS = os.path.join(CONFIG, "autoescuela_wavs")
|
||||||
|
|
||||||
|
VOCES = ["es_ES-sharvard-medium", "es_ES-davefx-medium", "es_ES-carlfm-x_low"]
|
||||||
|
VELOCIDADES = [0.9, 1.0, 1.12]
|
||||||
|
RUIDOS = ["", "aecho=0.8:0.7:22:0.12", "volume=0.72,highpass=f=120",
|
||||||
|
"highpass=f=150,lowpass=f=6500"]
|
||||||
|
|
||||||
|
# Lo que tiene efecto o pide permiso: se comprueba el emparejamiento pero no se
|
||||||
|
# ejecuta. Igual que en probar_acciones.
|
||||||
|
EFECTOS = ["firefox", "xdg-open", "loginctl", "xset", "pactl set", "pkill",
|
||||||
|
"brightnessctl", "systemctl start", "systemctl stop", "systemctl restart",
|
||||||
|
"import -window", "gnome-screenshot", "sudo", "rm ", "kill", "dpms"]
|
||||||
|
|
||||||
|
RELLENOS = ["notas", "el informe", "documentos", "reactor"]
|
||||||
|
|
||||||
|
|
||||||
|
def carga(ruta, nombre):
|
||||||
|
spec = importlib.util.spec_from_file_location(nombre, ruta)
|
||||||
|
m = importlib.util.module_from_spec(spec)
|
||||||
|
spec.loader.exec_module(m)
|
||||||
|
return m
|
||||||
|
|
||||||
|
|
||||||
|
def log(msg, a_dialogo=False):
|
||||||
|
linea = f"[{time.strftime('%H:%M:%S')}] {msg}"
|
||||||
|
print(linea, flush=True)
|
||||||
|
fichero = DIALOGO if a_dialogo else DIALOGO
|
||||||
|
try:
|
||||||
|
with open(fichero, "a") as f:
|
||||||
|
f.write((msg if a_dialogo else linea) + "\n")
|
||||||
|
except OSError:
|
||||||
|
pass
|
||||||
|
|
||||||
|
|
||||||
|
def dice(texto, voz, vel, ruido, destino):
|
||||||
|
"""El examinador dice una tarea: la sintetiza a un wav de 16 kHz."""
|
||||||
|
crudo = tempfile.mktemp(suffix=".wav")
|
||||||
|
try:
|
||||||
|
r = subprocess.run(
|
||||||
|
[PIPER, "--model", os.path.join(MODELOS_VOZ, voz + ".onnx"),
|
||||||
|
"--length_scale", str(1 / vel), "--output_file", crudo],
|
||||||
|
input=texto, capture_output=True, text=True, timeout=60)
|
||||||
|
if r.returncode != 0 or not os.path.exists(crudo):
|
||||||
|
return False
|
||||||
|
filtros = "aresample=16000" + ("," + ruido if ruido else "")
|
||||||
|
subprocess.run(["ffmpeg", "-hide_banner", "-loglevel", "error", "-i", crudo,
|
||||||
|
"-ac", "1", "-af", filtros, "-y", destino], check=True, timeout=60)
|
||||||
|
return True
|
||||||
|
except (OSError, subprocess.SubprocessError):
|
||||||
|
return False
|
||||||
|
finally:
|
||||||
|
if os.path.exists(crudo):
|
||||||
|
os.remove(crudo)
|
||||||
|
|
||||||
|
|
||||||
|
def oye(wavs, hilos=8, por_tanda=40):
|
||||||
|
"""Jarvis oye: transcribe los wav. {fichero: texto}."""
|
||||||
|
salida = {}
|
||||||
|
ficheros = sorted(wavs)
|
||||||
|
for i in range(0, len(ficheros), por_tanda):
|
||||||
|
tanda = ficheros[i:i + por_tanda]
|
||||||
|
lista = " ".join(f'"{WAVS}/{n}"' for n in tanda)
|
||||||
|
orden = (f'for f in {lista}; do echo "### $(basename "$f")"; '
|
||||||
|
f'{WHISPER} -m {MODELOS_STT}/ggml-base.bin -l es -nt -t {hilos} '
|
||||||
|
f'-f "$f" 2>/dev/null | tr "\\n" " "; echo; done')
|
||||||
|
try:
|
||||||
|
r = subprocess.run(["flatpak", "run", "--command=bash", APP, "-c", orden],
|
||||||
|
capture_output=True, text=True, errors="replace", timeout=1200)
|
||||||
|
except subprocess.SubprocessError:
|
||||||
|
continue
|
||||||
|
actual = None
|
||||||
|
for linea in r.stdout.splitlines():
|
||||||
|
if linea.startswith("### "):
|
||||||
|
actual = linea[4:].strip()
|
||||||
|
elif actual:
|
||||||
|
salida[actual] = linea.strip()
|
||||||
|
actual = None
|
||||||
|
return salida
|
||||||
|
|
||||||
|
|
||||||
|
def tiene_efecto(comando):
|
||||||
|
return any(m in comando for m in EFECTOS)
|
||||||
|
|
||||||
|
|
||||||
|
def ejecuta_lectura(comando, argumento=""):
|
||||||
|
"""Ejecuta un comando de solo lectura y devuelve su salida."""
|
||||||
|
c = comando.replace("{argumento}", shlex.quote(argumento))
|
||||||
|
c = c.replace("{argumento_url}", shlex.quote(argumento))
|
||||||
|
try:
|
||||||
|
r = subprocess.run(["bash", "-lc", c], capture_output=True, text=True,
|
||||||
|
errors="replace", timeout=15)
|
||||||
|
return (r.stdout or r.stderr or "").strip(), r.returncode
|
||||||
|
except subprocess.SubprocessError:
|
||||||
|
return "", 1
|
||||||
|
|
||||||
|
|
||||||
|
class Ejecutor:
|
||||||
|
"""La tuberia de Jarvis: oye una frase, decide y hace. Replica el enrutado
|
||||||
|
del panel (seleccion antes que catalogo) para poder probarlo sin GUI."""
|
||||||
|
|
||||||
|
def __init__(self, motor, seleccion):
|
||||||
|
self.motor = motor
|
||||||
|
self.sel = seleccion
|
||||||
|
self.cat = motor.Catalogo([p for p in (PROPIO, CATALOGO) if os.path.exists(p)]
|
||||||
|
or [CATALOGO_FUENTE])
|
||||||
|
self.lista = []
|
||||||
|
self.fichero = None
|
||||||
|
|
||||||
|
def recarga(self):
|
||||||
|
self.cat = self.motor.Catalogo(
|
||||||
|
[p for p in (PROPIO, CATALOGO) if os.path.exists(p)] or [CATALOGO_FUENTE])
|
||||||
|
|
||||||
|
def procesa(self, oido):
|
||||||
|
"""Devuelve (tipo, id_o_dato, salida). tipo:
|
||||||
|
'seleccion' | 'dentro' | 'accion' | 'modelo'."""
|
||||||
|
norm = self.motor.normaliza(oido)
|
||||||
|
|
||||||
|
s = self.sel.orden_de_seleccion(norm)
|
||||||
|
if s is not None and self.lista:
|
||||||
|
que, pos = s
|
||||||
|
idx = len(self.lista) - 1 if pos == -1 else pos - 1
|
||||||
|
if 0 <= idx < len(self.lista):
|
||||||
|
self.fichero = self.lista[idx]
|
||||||
|
return "seleccion", f"{que}:{pos}", self.fichero
|
||||||
|
return "seleccion", "fuera_de_rango", ""
|
||||||
|
|
||||||
|
termino = self.sel.orden_buscar_dentro(norm)
|
||||||
|
if termino and self.fichero:
|
||||||
|
r, _ = ejecuta_lectura(f"grep -in {shlex.quote(termino)} "
|
||||||
|
f"{shlex.quote(self.fichero)} | head", "")
|
||||||
|
return "dentro", termino, r
|
||||||
|
|
||||||
|
accion, arg = self.cat.busca(oido)
|
||||||
|
if accion is None:
|
||||||
|
return "modelo", "", ""
|
||||||
|
|
||||||
|
# las de lista alimentan self.lista
|
||||||
|
if accion.id in ("buscar_fichero", "buscar_carpeta", "grep_recursivo"):
|
||||||
|
salida, _ = ejecuta_lectura(accion.comando, arg)
|
||||||
|
rutas = [l.split(":", 1)[0] if accion.id == "grep_recursivo" else l
|
||||||
|
for l in salida.splitlines() if l.strip()]
|
||||||
|
self.lista = rutas
|
||||||
|
if rutas:
|
||||||
|
self.fichero = rutas[0]
|
||||||
|
return "accion", accion.id, salida
|
||||||
|
|
||||||
|
if accion.confirmar or tiene_efecto(accion.comando):
|
||||||
|
return "accion", accion.id, "(no se ejecuta; solo emparejamiento)"
|
||||||
|
|
||||||
|
salida, _ = ejecuta_lectura(accion.comando, arg)
|
||||||
|
return "accion", accion.id, salida
|
||||||
|
|
||||||
|
|
||||||
|
def escenarios(acciones):
|
||||||
|
"""Construye las tareas de examen. Cada una: (texto, comprobacion)."""
|
||||||
|
tareas = []
|
||||||
|
|
||||||
|
# un turno por accion: la tarea es su frase, se espera su id
|
||||||
|
for a in acciones:
|
||||||
|
if not a["frases"]:
|
||||||
|
continue
|
||||||
|
texto = a["frases"][0]
|
||||||
|
if a.get("captura"):
|
||||||
|
texto += " " + random.choice(RELLENOS)
|
||||||
|
tareas.append({
|
||||||
|
"tipo": "accion", "texto": texto, "espera_id": a["id"],
|
||||||
|
"turnos": [texto],
|
||||||
|
})
|
||||||
|
|
||||||
|
# multi-turno: probar el estado (lista -> elegir -> buscar dentro)
|
||||||
|
tareas.append({
|
||||||
|
"tipo": "multi", "texto": "buscar y elegir",
|
||||||
|
"turnos": ["busca el fichero reactor", "abre el primero", "busca dentro def"],
|
||||||
|
"espera": ["accion:grep_recursivo|accion:buscar_fichero", "seleccion", "dentro"],
|
||||||
|
})
|
||||||
|
|
||||||
|
# control negativo: charla que NO debe disparar accion
|
||||||
|
for frase in ["cuentame un chiste sobre gatos", "que opinas de todo esto",
|
||||||
|
"estoy cansado hoy la verdad", "no se muy bien que hacer ahora"]:
|
||||||
|
tareas.append({"tipo": "charla", "texto": frase, "turnos": [frase]})
|
||||||
|
|
||||||
|
return tareas
|
||||||
|
|
||||||
|
|
||||||
|
def una_tanda(ejecutor, motor, ronda, muestras):
|
||||||
|
acciones = ejecutor.cat.acciones
|
||||||
|
base_acciones = json.load(open(CATALOGO if os.path.exists(CATALOGO)
|
||||||
|
else CATALOGO_FUENTE))["acciones"]
|
||||||
|
tareas = escenarios(base_acciones)
|
||||||
|
|
||||||
|
# sintetizar todos los turnos
|
||||||
|
shutil.rmtree(WAVS, ignore_errors=True)
|
||||||
|
os.makedirs(WAVS, exist_ok=True)
|
||||||
|
plan = [] # (fichero, tarea_idx, turno_idx, texto)
|
||||||
|
n = 0
|
||||||
|
for ti, tarea in enumerate(tareas):
|
||||||
|
for tj, texto in enumerate(tarea["turnos"]):
|
||||||
|
n += 1
|
||||||
|
nombre = f"{n:05d}.wav"
|
||||||
|
if dice(texto, random.choice(VOCES), random.choice(VELOCIDADES),
|
||||||
|
random.choice(RUIDOS), os.path.join(WAVS, nombre)):
|
||||||
|
plan.append((nombre, ti, tj, texto))
|
||||||
|
|
||||||
|
log(f"ronda {ronda}: examinador dice {len(plan)} tareas, jarvis las oye...")
|
||||||
|
oidos = oye([p[0] for p in plan])
|
||||||
|
|
||||||
|
# correr los escenarios en orden (el estado importa en los multi-turno)
|
||||||
|
resultados = {"bien": 0, "reconoce_mal": 0, "accion_mal": 0,
|
||||||
|
"ejecuta_mal": 0, "charla_colada": 0}
|
||||||
|
candidatos = defaultdict(lambda: defaultdict(int))
|
||||||
|
por_tarea = defaultdict(list)
|
||||||
|
for nombre, ti, tj, texto in plan:
|
||||||
|
por_tarea[ti].append((tj, nombre, texto))
|
||||||
|
|
||||||
|
for ti in sorted(por_tarea):
|
||||||
|
tarea = tareas[ti]
|
||||||
|
ejecutor.lista = [] # cada escenario empieza limpio
|
||||||
|
ejecutor.fichero = None
|
||||||
|
for tj, nombre, texto in sorted(por_tarea[ti]):
|
||||||
|
oido = oidos.get(nombre, "").strip()
|
||||||
|
if not oido:
|
||||||
|
continue
|
||||||
|
tipo, dato, salida = ejecutor.procesa(oido)
|
||||||
|
|
||||||
|
# dejar la conversacion en el log, legible
|
||||||
|
log(f" examinador: «{texto}»", a_dialogo=True)
|
||||||
|
log(f" jarvis oye: «{oido}» -> {tipo}:{dato}", a_dialogo=True)
|
||||||
|
|
||||||
|
veredicto = verifica(tarea, tj, texto, oido, tipo, dato, salida,
|
||||||
|
motor, candidatos)
|
||||||
|
log(f" veredicto: {veredicto}\n", a_dialogo=True)
|
||||||
|
resultados[veredicto] = resultados.get(veredicto, 0) + 1
|
||||||
|
|
||||||
|
total = sum(resultados.values())
|
||||||
|
bien = resultados["bien"]
|
||||||
|
log(f"ronda {ronda}: {bien}/{total} bien · " +
|
||||||
|
" · ".join(f"{k} {v}" for k, v in resultados.items() if k != "bien" and v))
|
||||||
|
return resultados, candidatos
|
||||||
|
|
||||||
|
|
||||||
|
def verifica(tarea, tj, texto, oido, tipo, dato, salida, motor, candidatos):
|
||||||
|
"""Pone nota a un turno y, si es fallo de reconocimiento, anota el candidato."""
|
||||||
|
if tarea["tipo"] == "charla":
|
||||||
|
return "bien" if tipo == "modelo" else "charla_colada"
|
||||||
|
|
||||||
|
if tarea["tipo"] == "multi":
|
||||||
|
esperado = tarea["espera"][tj]
|
||||||
|
actual = f"{tipo}:{dato}"
|
||||||
|
if any(actual.startswith(e.split("|")[0].split(":")[0] + ":") and
|
||||||
|
(e == actual or e.split(":")[0] == tipo)
|
||||||
|
for e in esperado.split("|")):
|
||||||
|
# para multi basta con que el TIPO sea el correcto
|
||||||
|
if tipo in [e.split(":")[0] for e in esperado.split("|")]:
|
||||||
|
return "bien"
|
||||||
|
return "accion_mal"
|
||||||
|
|
||||||
|
# tarea de un turno: se espera un id concreto
|
||||||
|
espera_id = tarea["espera_id"]
|
||||||
|
if tipo != "accion":
|
||||||
|
# no reconocio la orden: candidato a alias si conserva sentido
|
||||||
|
candidatos[espera_id][motor.normaliza(oido)] += 1
|
||||||
|
return "reconoce_mal"
|
||||||
|
if dato != espera_id:
|
||||||
|
return "accion_mal"
|
||||||
|
# emparejo bien; ¿la ejecucion dio algo con sentido?
|
||||||
|
if salida and ("command not found" in salida or salida == "TIMEOUT"):
|
||||||
|
return "ejecuta_mal"
|
||||||
|
return "bien"
|
||||||
|
|
||||||
|
|
||||||
|
# --- aprender: mismos filtros seguros que mejora_nocturna --------------------
|
||||||
|
VACIAS = {"que", "de", "la", "el", "me", "se", "es", "esta", "estan", "hay",
|
||||||
|
"tengo", "un", "una", "por", "con", "como", "cuanto", "cuanta"}
|
||||||
|
|
||||||
|
|
||||||
|
def contenido(frase):
|
||||||
|
return {p for p in frase.split() if len(p) > 3 and p not in VACIAS}
|
||||||
|
|
||||||
|
|
||||||
|
def alias_seguros(candidatos, acciones, motor, cat):
|
||||||
|
porfrase = defaultdict(set)
|
||||||
|
for ident, frases in candidatos.items():
|
||||||
|
for f in frases:
|
||||||
|
porfrase[f].add(ident)
|
||||||
|
porid = {a["id"]: a for a in acciones}
|
||||||
|
propuestos = defaultdict(list)
|
||||||
|
for ident, frases in candidatos.items():
|
||||||
|
a = porid.get(ident)
|
||||||
|
if a is None or a.get("captura"):
|
||||||
|
continue
|
||||||
|
orig = motor.normaliza(a["frases"][0] if a["frases"] else "")
|
||||||
|
claves = contenido(orig)
|
||||||
|
for f, veces in frases.items():
|
||||||
|
if veces < 2 or len(porfrase[f]) > 1 or len(f.split()) < 2:
|
||||||
|
continue
|
||||||
|
if cat.busca(f)[0] is not None or motor.parecido(f, orig) < 0.6:
|
||||||
|
continue
|
||||||
|
pal = set(f.split())
|
||||||
|
if claves and not any(
|
||||||
|
c in pal or any(motor.parecido(c, w) > 0.8 for w in pal)
|
||||||
|
for c in claves):
|
||||||
|
continue
|
||||||
|
propuestos[ident].append((f, veces))
|
||||||
|
return propuestos
|
||||||
|
|
||||||
|
|
||||||
|
def guarda_alias(propuestos, acciones):
|
||||||
|
try:
|
||||||
|
propio = json.load(open(PROPIO))
|
||||||
|
except (OSError, json.JSONDecodeError):
|
||||||
|
propio = {"version": 1, "acciones": []}
|
||||||
|
porid = {a["id"]: a for a in propio.get("acciones", [])}
|
||||||
|
orig = {a["id"]: a for a in acciones}
|
||||||
|
n = 0
|
||||||
|
for ident, lista in propuestos.items():
|
||||||
|
e = porid.get(ident)
|
||||||
|
if e is None:
|
||||||
|
e = dict(orig[ident]); porid[ident] = e
|
||||||
|
propio.setdefault("acciones", []).append(e)
|
||||||
|
for f, _ in lista:
|
||||||
|
if f not in e["frases"]:
|
||||||
|
e["frases"].append(f); n += 1
|
||||||
|
json.dump(propio, open(PROPIO, "w"), indent=2, ensure_ascii=False)
|
||||||
|
return n
|
||||||
|
|
||||||
|
|
||||||
|
def main():
|
||||||
|
ap = argparse.ArgumentParser()
|
||||||
|
ap.add_argument("--horas", type=float, default=0)
|
||||||
|
ap.add_argument("--aplicar", action="store_true", help="guardar los alias que encuentre")
|
||||||
|
ap.add_argument("--muestras", type=int, default=1)
|
||||||
|
args = ap.parse_args()
|
||||||
|
|
||||||
|
for ruta, q in ((PIPER, "piper"), (WHISPER, "whisper")):
|
||||||
|
if not os.path.exists(ruta):
|
||||||
|
print(f"falta {q}"); return 1
|
||||||
|
|
||||||
|
os.makedirs(SALA, exist_ok=True)
|
||||||
|
motor = carga(MOTOR, "acciones")
|
||||||
|
sel = carga(SELECCION, "seleccion")
|
||||||
|
ejecutor = Ejecutor(motor, sel)
|
||||||
|
|
||||||
|
limite = time.time() + args.horas * 3600 if args.horas else None
|
||||||
|
log("=" * 56)
|
||||||
|
log("arranca la autoescuela (examinador + jarvis)")
|
||||||
|
|
||||||
|
historial = []
|
||||||
|
ronda = 0
|
||||||
|
total_alias = 0
|
||||||
|
while True:
|
||||||
|
ronda += 1
|
||||||
|
ini = time.time()
|
||||||
|
try:
|
||||||
|
resultados, candidatos = una_tanda(ejecutor, motor, ronda, args.muestras)
|
||||||
|
except Exception as e:
|
||||||
|
log(f"ronda {ronda}: error, se salta — {type(e).__name__}: {e}")
|
||||||
|
time.sleep(5); continue
|
||||||
|
|
||||||
|
# aprender de los fallos de reconocimiento
|
||||||
|
base = json.load(open(CATALOGO if os.path.exists(CATALOGO)
|
||||||
|
else CATALOGO_FUENTE))["acciones"]
|
||||||
|
propuestos = alias_seguros(candidatos, base, motor, ejecutor.cat)
|
||||||
|
nuevos = sum(len(v) for v in propuestos.values())
|
||||||
|
if nuevos and args.aplicar:
|
||||||
|
total_alias += guarda_alias(propuestos, base)
|
||||||
|
ejecutor.recarga()
|
||||||
|
log(f"ronda {ronda}: +{nuevos} alias aplicados")
|
||||||
|
elif nuevos:
|
||||||
|
log(f"ronda {ronda}: {nuevos} alias propuestos (usa --aplicar para guardarlos)")
|
||||||
|
|
||||||
|
total = sum(resultados.values())
|
||||||
|
historial.append({
|
||||||
|
"ronda": ronda,
|
||||||
|
"acierto": round(100 * resultados["bien"] / max(1, total), 1),
|
||||||
|
"fallos": {k: v for k, v in resultados.items() if k != "bien" and v},
|
||||||
|
"minutos": round((time.time() - ini) / 60, 1),
|
||||||
|
})
|
||||||
|
json.dump({"actualizado": time.strftime("%Y-%m-%d %H:%M"),
|
||||||
|
"rondas": ronda, "alias_aplicados": total_alias,
|
||||||
|
"historial": historial[-30:]},
|
||||||
|
open(INFORME, "w"), indent=2, ensure_ascii=False)
|
||||||
|
|
||||||
|
if not args.horas:
|
||||||
|
break
|
||||||
|
if time.time() > limite:
|
||||||
|
log("se acabo el tiempo. Fin."); break
|
||||||
|
|
||||||
|
shutil.rmtree(WAVS, ignore_errors=True)
|
||||||
|
log(f"terminado tras {ronda} rondas · ultimo acierto "
|
||||||
|
f"{historial[-1]['acierto'] if historial else '?'} %")
|
||||||
|
return 0
|
||||||
|
|
||||||
|
|
||||||
|
if __name__ == "__main__":
|
||||||
|
sys.exit(main())
|
||||||
185
config/banco.py
Executable file
185
config/banco.py
Executable file
|
|
@ -0,0 +1,185 @@
|
||||||
|
#!/usr/bin/env python3
|
||||||
|
"""Un banco de pruebas FIJO para medir si el reconocimiento mejora.
|
||||||
|
|
||||||
|
## El problema que resuelve
|
||||||
|
|
||||||
|
La mejora nocturna medía así: decía las 150 frases con voces, velocidades y
|
||||||
|
ruido ALEATORIOS, las transcribía, y comparaba el porcentaje con el de la ronda
|
||||||
|
anterior. Nueve horas y 39 rondas después:
|
||||||
|
|
||||||
|
ruido de medida (desviacion): ±1,9 puntos
|
||||||
|
mejora acumulada en la noche: +1,45 puntos
|
||||||
|
|
||||||
|
El ruido era MAYOR que la mejora. Con eso, la pregunta que el bucle necesita
|
||||||
|
contestar —"¿este alias mejora o empeora?"— se decidía a cara o cruz, y por eso
|
||||||
|
en nueve horas aplicó cuatro alias y no dejó ni un commit.
|
||||||
|
|
||||||
|
## Cómo lo arregla
|
||||||
|
|
||||||
|
Se graba el audio UNA vez, con semillas fijas, y se guardan las
|
||||||
|
TRANSCRIPCIONES. A partir de ahí, medir el catálogo es volver a pasar el
|
||||||
|
emparejador sobre esas mismas transcripciones guardadas:
|
||||||
|
|
||||||
|
- determinista: la misma entrada siempre, así que dos medidas son comparables
|
||||||
|
- instantáneo: sin TTS ni Whisper, milisegundos en vez de cinco minutos
|
||||||
|
- sensible: se nota una frase de diferencia, no hacen falta cuatro puntos
|
||||||
|
|
||||||
|
Lo que se pierde: deja de explorar ruidos nuevos. Por eso el banco se REHACE de
|
||||||
|
vez en cuando (--crear), y entre medias se usa fijo para decidir.
|
||||||
|
|
||||||
|
banco.py --crear [--muestras 2] graba y transcribe (lento, una vez)
|
||||||
|
banco.py --medir puntúa el catálogo actual (instantáneo)
|
||||||
|
banco.py --fallos enseña qué se sigue fallando
|
||||||
|
"""
|
||||||
|
import argparse
|
||||||
|
import collections
|
||||||
|
import importlib.util
|
||||||
|
import json
|
||||||
|
import os
|
||||||
|
import random
|
||||||
|
import subprocess
|
||||||
|
import sys
|
||||||
|
import tempfile
|
||||||
|
|
||||||
|
RAIZ = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
|
||||||
|
CATALOGO = os.path.join(RAIZ, "newelle", "data", "acciones", "acciones.json")
|
||||||
|
MOTOR = os.path.join(RAIZ, "newelle", "src", "utility", "acciones.py")
|
||||||
|
BANCO = os.path.join(RAIZ, "muestras", "banco.json")
|
||||||
|
PIPER = os.path.join(RAIZ, "config", "jarvis-piper.sh")
|
||||||
|
MODELO_WHISPER = os.path.expanduser(
|
||||||
|
"~/.var/app/io.github.qwersyk.Newelle/config/models/whisper/whisper.cpp/models/ggml-small.bin")
|
||||||
|
BIN_WHISPER = os.path.join(RAIZ, "voz", "whisper-cuda", "whisper.cpp", "build", "bin", "whisper-server")
|
||||||
|
|
||||||
|
# Fijas a proposito: son las que hacen el banco reproducible. Cambiarlas obliga
|
||||||
|
# a rehacerlo, y esa es justamente la señal de que ya no es comparable.
|
||||||
|
VOCES = ["es_ES-davefx-medium", "es_MX-claude-high", "es_ES-sharvard-medium"]
|
||||||
|
VELOCIDADES = [0.9, 1.0, 1.15]
|
||||||
|
SEMILLA = 20260815
|
||||||
|
|
||||||
|
|
||||||
|
def motor():
|
||||||
|
spec = importlib.util.spec_from_file_location("acciones", MOTOR)
|
||||||
|
m = importlib.util.module_from_spec(spec)
|
||||||
|
spec.loader.exec_module(m)
|
||||||
|
return m
|
||||||
|
|
||||||
|
|
||||||
|
def crear(muestras):
|
||||||
|
m = motor()
|
||||||
|
cat = m.Catalogo([CATALOGO])
|
||||||
|
rnd = random.Random(SEMILLA)
|
||||||
|
|
||||||
|
casos = []
|
||||||
|
for a in cat.acciones:
|
||||||
|
if not a.frases:
|
||||||
|
continue
|
||||||
|
for _ in range(muestras):
|
||||||
|
casos.append({
|
||||||
|
"id": a.id,
|
||||||
|
"frase": rnd.choice(a.frases),
|
||||||
|
"voz": rnd.choice(VOCES),
|
||||||
|
"velocidad": rnd.choice(VELOCIDADES),
|
||||||
|
})
|
||||||
|
print(f" {len(casos)} clips a grabar y transcribir...", flush=True)
|
||||||
|
|
||||||
|
puerto = 8993
|
||||||
|
servidor = subprocess.Popen(
|
||||||
|
[BIN_WHISPER, "-m", MODELO_WHISPER, "-t", "8", "--host", "127.0.0.1",
|
||||||
|
"--port", str(puerto), "-l", "es", "--no-gpu"],
|
||||||
|
stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL,
|
||||||
|
env={**os.environ, "LD_LIBRARY_PATH": "/usr/local/cuda/lib64"})
|
||||||
|
import time
|
||||||
|
time.sleep(10)
|
||||||
|
|
||||||
|
import urllib.request
|
||||||
|
hechos = 0
|
||||||
|
with tempfile.TemporaryDirectory() as tmp:
|
||||||
|
for c in casos:
|
||||||
|
wav = os.path.join(tmp, "c.wav")
|
||||||
|
entorno = {**os.environ,
|
||||||
|
"JARVIS_PIPER_VOZ": c["voz"],
|
||||||
|
"JARVIS_PIPER_TONO": "1.0"}
|
||||||
|
r = subprocess.run([PIPER, wav, c["frase"]], env=entorno,
|
||||||
|
capture_output=True, timeout=60)
|
||||||
|
if not os.path.exists(wav) or os.path.getsize(wav) == 0:
|
||||||
|
continue
|
||||||
|
# la velocidad se aplica al vuelo, sin tocar el tono
|
||||||
|
wav16 = os.path.join(tmp, "c16.wav")
|
||||||
|
subprocess.run(["ffmpeg", "-y", "-loglevel", "error", "-i", wav,
|
||||||
|
"-filter:a", f"atempo={c['velocidad']}",
|
||||||
|
"-ar", "16000", "-ac", "1", wav16],
|
||||||
|
capture_output=True, timeout=60)
|
||||||
|
try:
|
||||||
|
with open(wav16, "rb") as f:
|
||||||
|
datos = f.read()
|
||||||
|
lim = "----b"
|
||||||
|
cuerpo = (f"--{lim}\r\nContent-Disposition: form-data; "
|
||||||
|
f'name="file"; filename="c.wav"\r\n'
|
||||||
|
f"Content-Type: audio/wav\r\n\r\n").encode() + datos + \
|
||||||
|
f"\r\n--{lim}--\r\n".encode()
|
||||||
|
req = urllib.request.Request(
|
||||||
|
f"http://127.0.0.1:{puerto}/inference", data=cuerpo,
|
||||||
|
headers={"Content-Type": f"multipart/form-data; boundary={lim}"})
|
||||||
|
with urllib.request.urlopen(req, timeout=120) as resp:
|
||||||
|
c["oido"] = json.loads(resp.read().decode()).get("text", "").strip()
|
||||||
|
hechos += 1
|
||||||
|
if hechos % 50 == 0:
|
||||||
|
print(f" {hechos}/{len(casos)}", flush=True)
|
||||||
|
except Exception as e:
|
||||||
|
c["oido"] = ""
|
||||||
|
servidor.terminate()
|
||||||
|
|
||||||
|
casos = [c for c in casos if c.get("oido")]
|
||||||
|
os.makedirs(os.path.dirname(BANCO), exist_ok=True)
|
||||||
|
json.dump({"semilla": SEMILLA, "casos": casos}, open(BANCO, "w"),
|
||||||
|
ensure_ascii=False, indent=1)
|
||||||
|
print(f" banco guardado: {len(casos)} transcripciones en {BANCO}")
|
||||||
|
return 0
|
||||||
|
|
||||||
|
|
||||||
|
def cargar():
|
||||||
|
try:
|
||||||
|
return json.load(open(BANCO))["casos"]
|
||||||
|
except Exception:
|
||||||
|
return []
|
||||||
|
|
||||||
|
|
||||||
|
def medir(detalle=False):
|
||||||
|
casos = cargar()
|
||||||
|
if not casos:
|
||||||
|
print("no hay banco; crealo con --crear")
|
||||||
|
return 1
|
||||||
|
m = motor()
|
||||||
|
cat = m.Catalogo([CATALOGO])
|
||||||
|
aciertos, fallos = 0, []
|
||||||
|
for c in casos:
|
||||||
|
a, _ = cat.busca(c["oido"])
|
||||||
|
if a is not None and a.id == c["id"]:
|
||||||
|
aciertos += 1
|
||||||
|
else:
|
||||||
|
fallos.append((c["id"], c["oido"], a.id if a else None))
|
||||||
|
pct = 100.0 * aciertos / len(casos)
|
||||||
|
print(f" acierto {pct:.2f} % ({aciertos}/{len(casos)})")
|
||||||
|
if detalle:
|
||||||
|
cuenta = collections.Counter(f[0] for f in fallos)
|
||||||
|
print(f"\n las acciones que mas se fallan:")
|
||||||
|
for ident, n in cuenta.most_common(12):
|
||||||
|
ejemplo = next(f[1] for f in fallos if f[0] == ident)
|
||||||
|
print(f" {n:3d} {ident:22s} p.ej. se oyo: \"{ejemplo[:44]}\"")
|
||||||
|
return 0
|
||||||
|
|
||||||
|
|
||||||
|
def main():
|
||||||
|
p = argparse.ArgumentParser()
|
||||||
|
p.add_argument("--crear", action="store_true")
|
||||||
|
p.add_argument("--medir", action="store_true")
|
||||||
|
p.add_argument("--fallos", action="store_true")
|
||||||
|
p.add_argument("--muestras", type=int, default=2)
|
||||||
|
a = p.parse_args()
|
||||||
|
if a.crear:
|
||||||
|
return crear(a.muestras)
|
||||||
|
return medir(detalle=a.fallos)
|
||||||
|
|
||||||
|
|
||||||
|
if __name__ == "__main__":
|
||||||
|
sys.exit(main())
|
||||||
81
config/comparar_voces.py
Normal file
81
config/comparar_voces.py
Normal file
|
|
@ -0,0 +1,81 @@
|
||||||
|
#!/usr/bin/env python3
|
||||||
|
"""Genera la misma frase con las cuatro voces britanicas de Kokoro.
|
||||||
|
|
||||||
|
flatpak run --command=python3 io.github.qwersyk.Newelle//master \
|
||||||
|
~/COFRE/CODERS/JARVIS/config/comparar_voces.py
|
||||||
|
|
||||||
|
Todas salen ya con el tratamiento aplicado, que es como sonaran de verdad.
|
||||||
|
Elegir de oido y fijar la ganadora con set_voice.py.
|
||||||
|
"""
|
||||||
|
import os
|
||||||
|
import subprocess
|
||||||
|
import sys
|
||||||
|
|
||||||
|
sys.path.insert(0, "/app/share/newelle")
|
||||||
|
sys.path.insert(0, os.path.expanduser(
|
||||||
|
"~/.var/app/io.github.qwersyk.Newelle/config/pip"))
|
||||||
|
|
||||||
|
from gi.repository import Gio # noqa: E402
|
||||||
|
|
||||||
|
from newelle.handlers.tts.kokoro_handler import KokoroTTSHandler # noqa: E402
|
||||||
|
from newelle.handlers.tts.tts import jarvis_audio_filter # noqa: E402
|
||||||
|
|
||||||
|
VOCES = ["bm_george", "bm_daniel", "bm_lewis", "bm_fable"]
|
||||||
|
|
||||||
|
FRASE = ("Good evening, sir. All systems are running locally. "
|
||||||
|
"The GPU is idle, and you have 846 gigabytes free. "
|
||||||
|
"Shall I run the diagnostics?")
|
||||||
|
|
||||||
|
SALIDA = os.path.expanduser("~/COFRE/CODERS/JARVIS/muestras/voces")
|
||||||
|
CONFIG = os.path.expanduser("~/.var/app/io.github.qwersyk.Newelle/config")
|
||||||
|
|
||||||
|
|
||||||
|
def nivel(path):
|
||||||
|
"""mean/max en dB, para confirmar que ninguna sale floja o recortada."""
|
||||||
|
r = subprocess.run(
|
||||||
|
["ffmpeg", "-hide_banner", "-i", path, "-af", "volumedetect",
|
||||||
|
"-f", "null", "/dev/null"],
|
||||||
|
capture_output=True, text=True,
|
||||||
|
)
|
||||||
|
vals = [l.split(":")[-1].strip() for l in r.stderr.splitlines()
|
||||||
|
if "mean_volume:" in l or "max_volume:" in l]
|
||||||
|
return " / ".join(vals) if vals else "?"
|
||||||
|
|
||||||
|
|
||||||
|
def main():
|
||||||
|
os.makedirs(SALIDA, exist_ok=True)
|
||||||
|
settings = Gio.Settings.new("io.github.qwersyk.Newelle")
|
||||||
|
handler = KokoroTTSHandler(settings, os.path.join(CONFIG, "models"))
|
||||||
|
|
||||||
|
if not handler.is_installed():
|
||||||
|
print("instalando kokoro...")
|
||||||
|
handler.install()
|
||||||
|
|
||||||
|
filtro = jarvis_audio_filter()
|
||||||
|
print(f"{'voz':<12} {'fichero':<26} nivel (mean / max)")
|
||||||
|
|
||||||
|
for voz in VOCES:
|
||||||
|
handler.set_voice(voz)
|
||||||
|
crudo = os.path.join(SALIDA, f"_{voz}_seca.wav")
|
||||||
|
final = os.path.join(SALIDA, f"{voz}.wav")
|
||||||
|
try:
|
||||||
|
handler.save_audio(FRASE, crudo)
|
||||||
|
subprocess.run(
|
||||||
|
["ffmpeg", "-hide_banner", "-loglevel", "error",
|
||||||
|
"-i", crudo, "-af", filtro, "-y", final],
|
||||||
|
check=True,
|
||||||
|
)
|
||||||
|
os.remove(crudo)
|
||||||
|
print(f"{voz:<12} {os.path.basename(final):<26} {nivel(final)}")
|
||||||
|
except Exception as e:
|
||||||
|
print(f"{voz:<12} FALLO: {e}")
|
||||||
|
|
||||||
|
# dejar la voz como estaba, que este script solo compara
|
||||||
|
handler.set_voice(VOCES[0])
|
||||||
|
print(f"\nvoz restaurada a {VOCES[0]}")
|
||||||
|
print(f"escuchalas en: {SALIDA}")
|
||||||
|
return 0
|
||||||
|
|
||||||
|
|
||||||
|
if __name__ == "__main__":
|
||||||
|
sys.exit(main())
|
||||||
108
config/comparar_voces_es.py
Normal file
108
config/comparar_voces_es.py
Normal file
|
|
@ -0,0 +1,108 @@
|
||||||
|
#!/usr/bin/env python3
|
||||||
|
"""Genera la misma frase en castellano con las voces masculinas disponibles.
|
||||||
|
|
||||||
|
flatpak run --command=python3 io.github.qwersyk.Newelle//master \
|
||||||
|
~/COFRE/CODERS/JARVIS/config/comparar_voces_es.py
|
||||||
|
|
||||||
|
Kokoro solo trae DOS voces masculinas en español: em_alex y em_santa. De los
|
||||||
|
motores que Newelle soporta, los unicos locales son kokoro y espeak; el resto
|
||||||
|
—gtts, edge, elevenlabs, openai, groq— son de nube y quedan descartados.
|
||||||
|
|
||||||
|
Como ninguna de las dos es especialmente grave, cada una se genera tambien en
|
||||||
|
version grave: se baja el tono con ffmpeg sin cambiar la velocidad. El truco es
|
||||||
|
reproducir a menos muestras por segundo (baja tono y alarga) y devolver la
|
||||||
|
duracion con atempo. A 0.90 baja unos dos semitonos, que se nota sin sonar a
|
||||||
|
disco rayado; por debajo de 0.85 empieza a sonar artificial.
|
||||||
|
|
||||||
|
Se escuchan las cuatro y se fija la elegida con set_voz_es.py.
|
||||||
|
"""
|
||||||
|
import os
|
||||||
|
import subprocess
|
||||||
|
import sys
|
||||||
|
|
||||||
|
sys.path.insert(0, "/app/share/newelle")
|
||||||
|
sys.path.insert(0, os.path.expanduser(
|
||||||
|
"~/.var/app/io.github.qwersyk.Newelle/config/pip"))
|
||||||
|
|
||||||
|
from gi.repository import Gio # noqa: E402
|
||||||
|
|
||||||
|
from newelle.handlers.tts.kokoro_handler import KokoroTTSHandler # noqa: E402
|
||||||
|
from newelle.handlers.tts.tts import jarvis_audio_filter # noqa: E402
|
||||||
|
|
||||||
|
VOCES = ["em_alex", "em_santa"]
|
||||||
|
GRAVEDAD = 0.90 # 1.0 = sin tocar; menos = mas grave
|
||||||
|
MUESTREO = 24000 # el que saca kokoro
|
||||||
|
|
||||||
|
FRASE = ("Buenas tardes. Todos los sistemas funcionan en local. "
|
||||||
|
"La tarjeta grafica esta libre y quedan ochocientos cuarenta y seis "
|
||||||
|
"gigabytes en el disco. Quiere que ejecute el diagnostico?")
|
||||||
|
|
||||||
|
SALIDA = os.path.expanduser("~/COFRE/CODERS/JARVIS/muestras/voces_es")
|
||||||
|
CONFIG = os.path.expanduser("~/.var/app/io.github.qwersyk.Newelle/config")
|
||||||
|
|
||||||
|
|
||||||
|
def cadena(grave: bool) -> str:
|
||||||
|
"""El tratamiento JARVIS, con o sin bajada de tono delante."""
|
||||||
|
base = jarvis_audio_filter()
|
||||||
|
if not grave:
|
||||||
|
return base
|
||||||
|
tono = (f"asetrate={int(MUESTREO * GRAVEDAD)},"
|
||||||
|
f"aresample={MUESTREO},atempo={1 / GRAVEDAD:.4f}")
|
||||||
|
return f"{tono},{base}" if base else tono
|
||||||
|
|
||||||
|
|
||||||
|
def nivel(path):
|
||||||
|
"""mean/max en dB, para confirmar que ninguna sale floja o recortada."""
|
||||||
|
r = subprocess.run(
|
||||||
|
["ffmpeg", "-hide_banner", "-i", path, "-af", "volumedetect",
|
||||||
|
"-f", "null", "/dev/null"],
|
||||||
|
capture_output=True, text=True,
|
||||||
|
)
|
||||||
|
vals = [l.split(":")[-1].strip() for l in r.stderr.splitlines()
|
||||||
|
if "mean_volume:" in l or "max_volume:" in l]
|
||||||
|
return " / ".join(vals) if vals else "?"
|
||||||
|
|
||||||
|
|
||||||
|
def main():
|
||||||
|
os.makedirs(SALIDA, exist_ok=True)
|
||||||
|
settings = Gio.Settings.new("io.github.qwersyk.Newelle")
|
||||||
|
handler = KokoroTTSHandler(settings, os.path.join(CONFIG, "models"))
|
||||||
|
|
||||||
|
if not handler.is_installed():
|
||||||
|
print("instalando kokoro...")
|
||||||
|
handler.install()
|
||||||
|
|
||||||
|
previa = handler.get_current_voice() if hasattr(handler, "get_current_voice") else None
|
||||||
|
print(f"{'fichero':<28} nivel (mean / max)")
|
||||||
|
|
||||||
|
for voz in VOCES:
|
||||||
|
handler.set_voice(voz)
|
||||||
|
crudo = os.path.join(SALIDA, f"_{voz}.wav")
|
||||||
|
try:
|
||||||
|
handler.save_audio(FRASE, crudo)
|
||||||
|
except Exception as e:
|
||||||
|
print(f"{voz:<28} FALLO al generar: {e}")
|
||||||
|
continue
|
||||||
|
|
||||||
|
for etiqueta, grave in (("", False), ("_grave", True)):
|
||||||
|
final = os.path.join(SALIDA, f"{voz}{etiqueta}.wav")
|
||||||
|
try:
|
||||||
|
subprocess.run(
|
||||||
|
["ffmpeg", "-hide_banner", "-loglevel", "error",
|
||||||
|
"-i", crudo, "-af", cadena(grave), "-y", final],
|
||||||
|
check=True,
|
||||||
|
)
|
||||||
|
print(f"{os.path.basename(final):<28} {nivel(final)}")
|
||||||
|
except Exception as e:
|
||||||
|
print(f"{voz}{etiqueta:<20} FALLO: {e}")
|
||||||
|
os.remove(crudo)
|
||||||
|
|
||||||
|
if previa:
|
||||||
|
handler.set_voice(previa)
|
||||||
|
print(f"\nescuchalas en: {SALIDA}")
|
||||||
|
print("la elegida se fija con set_voz_es.py <voz> [--grave]")
|
||||||
|
return 0
|
||||||
|
|
||||||
|
|
||||||
|
if __name__ == "__main__":
|
||||||
|
sys.exit(main())
|
||||||
101
config/construir_indice.py
Normal file
101
config/construir_indice.py
Normal file
|
|
@ -0,0 +1,101 @@
|
||||||
|
#!/usr/bin/env python3
|
||||||
|
"""Construye el indice del RAG sin abrir la interfaz.
|
||||||
|
|
||||||
|
flatpak run --command=python3 io.github.qwersyk.Newelle//master \
|
||||||
|
~/COFRE/CODERS/JARVIS/config/construir_indice.py
|
||||||
|
|
||||||
|
En la app esto es el boton "Update Index" de los ajustes del RAG, que lanza un
|
||||||
|
hilo y va enseñando el progreso en una barra. Desde aqui se llama a lo mismo
|
||||||
|
pero en primer plano, para poder dejarlo corriendo en una terminal y ver si
|
||||||
|
falla, que con 20 000 fragmentos conviene.
|
||||||
|
|
||||||
|
Antes hay que haber preparado el corpus con indexar.py: este script indexa lo
|
||||||
|
que haya en la carpeta de documentos, sin filtrar nada.
|
||||||
|
"""
|
||||||
|
import os
|
||||||
|
import sys
|
||||||
|
import time
|
||||||
|
|
||||||
|
sys.path.insert(0, "/app/share/newelle")
|
||||||
|
sys.path.insert(0, os.path.expanduser(
|
||||||
|
"~/.var/app/io.github.qwersyk.Newelle/config/pip"))
|
||||||
|
|
||||||
|
from gi.repository import Gio # noqa: E402
|
||||||
|
|
||||||
|
from newelle.handlers.rag.llamaindex_handler import LlamaIndexHanlder # noqa: E402
|
||||||
|
from newelle.handlers.embeddings.model2vec import Model2VecHandler # noqa: E402
|
||||||
|
|
||||||
|
CONFIG = os.path.expanduser("~/.var/app/io.github.qwersyk.Newelle/config")
|
||||||
|
MODELOS = os.path.join(CONFIG, "models")
|
||||||
|
DOCUMENTOS = os.path.join(MODELOS, "documents")
|
||||||
|
|
||||||
|
|
||||||
|
def main():
|
||||||
|
if not os.path.isdir(DOCUMENTOS):
|
||||||
|
print(f"no existe {DOCUMENTOS}")
|
||||||
|
print("prepara antes el corpus: python3 config/indexar.py --hacerlo")
|
||||||
|
return 1
|
||||||
|
|
||||||
|
ficheros = [f for f in os.listdir(DOCUMENTOS) if not f.startswith(".")]
|
||||||
|
if not ficheros:
|
||||||
|
print("la carpeta de documentos esta vacia")
|
||||||
|
return 1
|
||||||
|
|
||||||
|
tam = sum(os.path.getsize(os.path.join(DOCUMENTOS, f))
|
||||||
|
for f in ficheros) / 1048576
|
||||||
|
print(f"{len(ficheros)} documentos · {tam:.1f} MB")
|
||||||
|
|
||||||
|
settings = Gio.Settings.new("io.github.qwersyk.Newelle")
|
||||||
|
rag = LlamaIndexHanlder(settings, MODELOS)
|
||||||
|
|
||||||
|
if not rag.is_installed():
|
||||||
|
print("faltan dependencias del RAG (llama-index, faiss, tiktoken)")
|
||||||
|
return 1
|
||||||
|
|
||||||
|
# El RAG necesita el modelo de embeddings para vectorizar, y opcionalmente
|
||||||
|
# un LLM secundario para reescribir la consulta. Aqui solo hace falta el
|
||||||
|
# primero: se indexa, no se pregunta.
|
||||||
|
rag.embedding = Model2VecHandler(settings, MODELOS)
|
||||||
|
if not rag.embedding.is_installed():
|
||||||
|
print("instalando model2vec...")
|
||||||
|
rag.embedding.install()
|
||||||
|
# create_index solo le pide load_model() al LLM —para indexar no hace falta
|
||||||
|
# generar nada— asi que un cascaron sirve y evita cargar 3,7 GB de modelo
|
||||||
|
# para vectorizar documentos.
|
||||||
|
class SinModelo:
|
||||||
|
def load_model(self, *a, **k):
|
||||||
|
return True
|
||||||
|
|
||||||
|
rag.llm = SinModelo()
|
||||||
|
rag.secondary_llm = SinModelo()
|
||||||
|
|
||||||
|
trozo = rag.get_setting("chunk_size")
|
||||||
|
print(f"fragmentos de {trozo} tokens · esto tarda, no lo cortes\n")
|
||||||
|
|
||||||
|
ini = time.time()
|
||||||
|
try:
|
||||||
|
rag.create_index()
|
||||||
|
except Exception as e:
|
||||||
|
print(f"\nfallo al indexar: {type(e).__name__}: {e}")
|
||||||
|
return 1
|
||||||
|
|
||||||
|
minutos = (time.time() - ini) / 60
|
||||||
|
_, data_path = rag.get_paths()
|
||||||
|
peso = sum(
|
||||||
|
os.path.getsize(os.path.join(dp, f))
|
||||||
|
for dp, _, fs in os.walk(data_path) for f in fs) / 1048576
|
||||||
|
|
||||||
|
# create_index se traga sus propias excepciones e imprime el error, asi que
|
||||||
|
# terminar sin fallo no significa que haya indice. Se comprueba el disco.
|
||||||
|
if peso < 0.1:
|
||||||
|
print(f"\nno se creo indice ({peso:.1f} MB en {data_path})")
|
||||||
|
print("mira el error de arriba")
|
||||||
|
return 1
|
||||||
|
|
||||||
|
print(f"\nindice construido en {minutos:.1f} min · {peso:.1f} MB")
|
||||||
|
print(f"en {data_path}")
|
||||||
|
return 0
|
||||||
|
|
||||||
|
|
||||||
|
if __name__ == "__main__":
|
||||||
|
sys.exit(main())
|
||||||
94
config/demo_en_directo.sh
Executable file
94
config/demo_en_directo.sh
Executable file
|
|
@ -0,0 +1,94 @@
|
||||||
|
#!/usr/bin/env bash
|
||||||
|
# Le da ordenes a JARVIS en directo, para verlo trabajar en la pantalla.
|
||||||
|
#
|
||||||
|
# Cada orden se dice EN VOZ ALTA con la voz activa (para oir como suena de
|
||||||
|
# verdad, no en un banco de pruebas) y luego se ejecuta la accion que le
|
||||||
|
# corresponde, igual que haria el asistente al oirte.
|
||||||
|
#
|
||||||
|
# No se ejecuta nada destructivo ni nada con root: eso pasa por un dialogo que
|
||||||
|
# aprueba una persona, y aqui no hay persona delante del dialogo.
|
||||||
|
#
|
||||||
|
# ./demo_en_directo.sh las que salen por pantalla incluidas
|
||||||
|
# ./demo_en_directo.sh --mudo sin voz, solo resultados
|
||||||
|
set -uo pipefail
|
||||||
|
RAIZ=$(cd -P "$(dirname "${BASH_SOURCE[0]:-$0}")/.." && pwd)
|
||||||
|
MUDO=no; [ "${1:-}" = "--mudo" ] && MUDO=si
|
||||||
|
|
||||||
|
CATALOGO=$RAIZ/newelle/data/acciones/acciones.json
|
||||||
|
TMPWAV=$(mktemp --suffix=.wav)
|
||||||
|
trap 'rm -f "$TMPWAV"' EXIT
|
||||||
|
|
||||||
|
# La orden que se le diria, y la accion del catalogo que le toca.
|
||||||
|
# Se eligen las que se VEN o las que contestan algo concreto.
|
||||||
|
ORDENES=(
|
||||||
|
"cuanto espacio queda|disco_libre"
|
||||||
|
"cuanta memoria|memoria"
|
||||||
|
"que temperatura hay|temperatura"
|
||||||
|
"que procesos consumen mas|procesos_top"
|
||||||
|
"cual es mi ip|red_ip"
|
||||||
|
"cuanto lleva encendido|uptime"
|
||||||
|
"busca el fichero README|buscar_fichero|README.md"
|
||||||
|
"busca dentro JARVIS|grep_recursivo|JARVIS"
|
||||||
|
"hazme una captura|captura_pantalla"
|
||||||
|
"abre una terminal|terminal_abrir"
|
||||||
|
"que peliculas tengo|videos_listar"
|
||||||
|
"pon la pelicula screencast|pelicula_abrir|Screencast"
|
||||||
|
"abre la carpeta de jarvis|abrir_carpeta|$RAIZ"
|
||||||
|
)
|
||||||
|
|
||||||
|
dice() {
|
||||||
|
[ "$MUDO" = si ] && return 0
|
||||||
|
"$RAIZ/config/jarvis-voz.sh" "$TMPWAV" "$1" >/dev/null 2>&1 \
|
||||||
|
|| JARVIS_PIPER_VOZ=es_ES-davefx-medium "$RAIZ/config/jarvis-piper.sh" "$TMPWAV" "$1" >/dev/null 2>&1
|
||||||
|
[ -s "$TMPWAV" ] && { paplay "$TMPWAV" 2>/dev/null || aplay -q "$TMPWAV" 2>/dev/null; }
|
||||||
|
}
|
||||||
|
|
||||||
|
campo() { # campo <id_accion> <clave>
|
||||||
|
python3 -c "
|
||||||
|
import json,sys
|
||||||
|
d=json.load(open('$CATALOGO',encoding='utf-8'))
|
||||||
|
for a in d.get('acciones', d if isinstance(d,list) else []):
|
||||||
|
if a['id']==sys.argv[1]: print(a.get(sys.argv[2],'') or ''); break
|
||||||
|
" "$1" "$2"
|
||||||
|
}
|
||||||
|
|
||||||
|
for entrada in "${ORDENES[@]}"; do
|
||||||
|
IFS='|' read -r frase accion argumento <<< "$entrada"
|
||||||
|
comando=$(campo "$accion" comando)
|
||||||
|
acuse=$(campo "$accion" acuse)
|
||||||
|
respuesta=$(campo "$accion" respuesta)
|
||||||
|
|
||||||
|
if [ -z "$comando" ]; then
|
||||||
|
printf '\n ── "%s" → accion %s NO EXISTE en el catalogo\n' "$frase" "$accion"
|
||||||
|
continue
|
||||||
|
fi
|
||||||
|
|
||||||
|
printf '\n ── tu dices: "%s"\n' "$frase"
|
||||||
|
printf ' jarvis: %s\n' "${acuse:-...}"
|
||||||
|
dice "${acuse:-Un momento}"
|
||||||
|
|
||||||
|
# sustituir el argumento igual que hace el motor
|
||||||
|
real=${comando//\{argumento\}/$(printf '%q' "${argumento:-}")}
|
||||||
|
salida=$(timeout 30 bash -lc "$real" 2>&1 | head -6)
|
||||||
|
|
||||||
|
if [ -n "$salida" ]; then
|
||||||
|
printf ' resultado: %s\n' "$(echo "$salida" | head -1 | cut -c1-100)"
|
||||||
|
echo "$salida" | tail -n +2 | sed 's/^/ /' | cut -c1-100
|
||||||
|
else
|
||||||
|
printf ' resultado: (hecho, sin salida que enseñar)\n'
|
||||||
|
fi
|
||||||
|
|
||||||
|
# decir la respuesta con la plantilla, si la tiene y es corta
|
||||||
|
if [ -n "$respuesta" ] && [ -n "$salida" ]; then
|
||||||
|
ultima=$(echo "$salida" | tail -1)
|
||||||
|
hablado=${respuesta//\{ultima\}/$ultima}
|
||||||
|
hablado=${hablado//\{salida\}/$ultima}
|
||||||
|
case "$hablado" in
|
||||||
|
*"{"*) ;; # plantilla con campos que no sabemos
|
||||||
|
*) [ ${#hablado} -lt 160 ] && { printf ' jarvis: %s\n' "$hablado"; dice "$hablado"; };;
|
||||||
|
esac
|
||||||
|
fi
|
||||||
|
sleep 1
|
||||||
|
done
|
||||||
|
|
||||||
|
printf '\n ── fin de la demostracion\n'
|
||||||
190
config/descubrir.py
Executable file
190
config/descubrir.py
Executable file
|
|
@ -0,0 +1,190 @@
|
||||||
|
#!/usr/bin/env python3
|
||||||
|
"""Cataloga las herramientas de COFRE para que JARVIS sepa cuales hay.
|
||||||
|
|
||||||
|
python3 ~/COFRE/CODERS/JARVIS/config/descubrir.py
|
||||||
|
|
||||||
|
Produce jarvis-herramientas.json: una ficha por herramienta con su nombre, que
|
||||||
|
hace, como se invoca y en que carpeta vive. NO es el catalogo de acciones
|
||||||
|
rapidas (esas son las ~20 que dices por voz a diario, escritas a mano). Esto es
|
||||||
|
el registro que el modelo consulta cuando le pides algo que no esta en el
|
||||||
|
catalogo, para componer el comando en vez de inventarselo.
|
||||||
|
|
||||||
|
Que hace y que NO hace:
|
||||||
|
- SI: encuentra los puntos de entrada reales (scripts con shebang y binarios
|
||||||
|
en los primeros niveles de cada proyecto, no los modulos internos).
|
||||||
|
- SI: saca una descripcion del README, del docstring o de la cabecera, SIN
|
||||||
|
ejecutar nada. Ejecutar un script desconocido con --help para leerlo seria
|
||||||
|
ejecutar un script desconocido, que es justo lo que no se quiere hacer a
|
||||||
|
ciegas.
|
||||||
|
- NO: ejecuta ninguna herramienta. Esto solo mira.
|
||||||
|
|
||||||
|
El resultado se revisa a mano antes de usarlo: es material de terceros y algun
|
||||||
|
"tool" sera un ejemplo o un exploit, no algo que quieras ofrecer.
|
||||||
|
"""
|
||||||
|
import ast
|
||||||
|
import json
|
||||||
|
import os
|
||||||
|
import re
|
||||||
|
import stat
|
||||||
|
import sys
|
||||||
|
|
||||||
|
COFRE = os.path.expanduser("~/COFRE")
|
||||||
|
SALIDA = os.path.expanduser("~/COFRE/CODERS/JARVIS/config/jarvis-herramientas.json")
|
||||||
|
|
||||||
|
CARPETAS = ["CODERS", "PENTESTERS", "AUTOMATAS", "DOSER", "HARD-WARERS",
|
||||||
|
"PHISHERS", "PROTECTORS", "REVERSERS", "SNEAKERS"]
|
||||||
|
|
||||||
|
# Solo los primeros niveles: un punto de entrada vive cerca de la raiz del
|
||||||
|
# proyecto, no enterrado en lib/ o en site-packages.
|
||||||
|
PROFUNDIDAD = 3
|
||||||
|
|
||||||
|
FUERA = {"node_modules", ".git", "venv", ".venv", "site-packages", "__pycache__",
|
||||||
|
"lib", "libs", "tests", "test", "docs", "examples", "vendor", "dist",
|
||||||
|
"build", ".tox", "exploitdb"}
|
||||||
|
|
||||||
|
# Nombres que casi nunca son la herramienta en si
|
||||||
|
IGNORAR_NOMBRES = {"setup.py", "conftest.py", "__init__.py", "test.py",
|
||||||
|
"tests.py", "wsgi.py", "manage.py", "conf.py"}
|
||||||
|
|
||||||
|
|
||||||
|
def es_ejecutable(ruta: str) -> bool:
|
||||||
|
try:
|
||||||
|
return bool(os.stat(ruta).st_mode & stat.S_IXUSR)
|
||||||
|
except OSError:
|
||||||
|
return False
|
||||||
|
|
||||||
|
|
||||||
|
def tiene_shebang(ruta: str) -> bool:
|
||||||
|
try:
|
||||||
|
with open(ruta, "rb") as f:
|
||||||
|
return f.read(2) == b"#!"
|
||||||
|
except OSError:
|
||||||
|
return False
|
||||||
|
|
||||||
|
|
||||||
|
def descripcion_readme(carpeta: str) -> str:
|
||||||
|
"""Primera linea con contenido de un README cercano."""
|
||||||
|
for nombre in ("README.md", "README.rst", "README.txt", "README"):
|
||||||
|
ruta = os.path.join(carpeta, nombre)
|
||||||
|
if not os.path.exists(ruta):
|
||||||
|
continue
|
||||||
|
try:
|
||||||
|
with open(ruta, errors="ignore") as f:
|
||||||
|
for linea in f:
|
||||||
|
limpia = linea.strip().lstrip("#").lstrip(">").strip()
|
||||||
|
# saltar titulos de una palabra, badges y separadores
|
||||||
|
if len(limpia) > 25 and not limpia.startswith(("![", "[!", "---", "===")):
|
||||||
|
return limpia[:200]
|
||||||
|
except OSError:
|
||||||
|
pass
|
||||||
|
return ""
|
||||||
|
|
||||||
|
|
||||||
|
def descripcion_script(ruta: str) -> str:
|
||||||
|
"""Docstring del modulo (Python) o cabecera de comentarios (shell)."""
|
||||||
|
try:
|
||||||
|
with open(ruta, errors="ignore") as f:
|
||||||
|
texto = f.read(4000)
|
||||||
|
except OSError:
|
||||||
|
return ""
|
||||||
|
|
||||||
|
if ruta.endswith(".py"):
|
||||||
|
try:
|
||||||
|
doc = ast.get_docstring(ast.parse(texto))
|
||||||
|
if doc:
|
||||||
|
return doc.strip().split("\n")[0][:200]
|
||||||
|
except (SyntaxError, ValueError):
|
||||||
|
pass
|
||||||
|
|
||||||
|
# cabecera de comentarios: las primeras lineas que empiezan por # tras el shebang
|
||||||
|
lineas = []
|
||||||
|
for linea in texto.splitlines()[1:8]:
|
||||||
|
s = linea.strip()
|
||||||
|
if s.startswith("#"):
|
||||||
|
limpio = s.lstrip("#").strip()
|
||||||
|
if len(limpio) > 15:
|
||||||
|
lineas.append(limpio)
|
||||||
|
elif lineas:
|
||||||
|
break
|
||||||
|
return " ".join(lineas)[:200]
|
||||||
|
|
||||||
|
|
||||||
|
def recorre():
|
||||||
|
herramientas = []
|
||||||
|
vistos = set()
|
||||||
|
|
||||||
|
for carpeta in CARPETAS:
|
||||||
|
raiz = os.path.join(COFRE, carpeta)
|
||||||
|
if not os.path.isdir(raiz):
|
||||||
|
continue
|
||||||
|
|
||||||
|
for dirpath, dirnames, ficheros in os.walk(raiz):
|
||||||
|
profundidad = dirpath[len(raiz):].count(os.sep)
|
||||||
|
if profundidad >= PROFUNDIDAD:
|
||||||
|
dirnames[:] = []
|
||||||
|
continue
|
||||||
|
dirnames[:] = [d for d in dirnames
|
||||||
|
if d not in FUERA and not d.startswith(".")]
|
||||||
|
|
||||||
|
for nombre in ficheros:
|
||||||
|
if nombre in IGNORAR_NOMBRES:
|
||||||
|
continue
|
||||||
|
ruta = os.path.join(dirpath, nombre)
|
||||||
|
ext = os.path.splitext(nombre)[1].lower()
|
||||||
|
|
||||||
|
es_script = ext in (".py", ".sh") and (tiene_shebang(ruta) or es_ejecutable(ruta))
|
||||||
|
es_binario = not ext and es_ejecutable(ruta) and not tiene_shebang(ruta)
|
||||||
|
if not (es_script or es_binario):
|
||||||
|
continue
|
||||||
|
|
||||||
|
clave = nombre.lower()
|
||||||
|
if clave in vistos:
|
||||||
|
continue
|
||||||
|
vistos.add(clave)
|
||||||
|
|
||||||
|
desc = descripcion_script(ruta) if es_script else ""
|
||||||
|
if not desc:
|
||||||
|
desc = descripcion_readme(dirpath)
|
||||||
|
|
||||||
|
herramientas.append({
|
||||||
|
"nombre": os.path.splitext(nombre)[0],
|
||||||
|
"carpeta": carpeta,
|
||||||
|
"ruta": ruta,
|
||||||
|
"tipo": "python" if ext == ".py" else "shell" if ext == ".sh" else "binario",
|
||||||
|
"descripcion": desc,
|
||||||
|
"invocar": (f"python3 {ruta}" if ext == ".py"
|
||||||
|
else f"bash {ruta}" if ext == ".sh"
|
||||||
|
else ruta),
|
||||||
|
})
|
||||||
|
|
||||||
|
return herramientas
|
||||||
|
|
||||||
|
|
||||||
|
def main():
|
||||||
|
print("recorriendo COFRE (solo lectura, no se ejecuta nada)...\n", flush=True)
|
||||||
|
tools = recorre()
|
||||||
|
|
||||||
|
porcarpeta = {}
|
||||||
|
con_desc = 0
|
||||||
|
for t in tools:
|
||||||
|
porcarpeta[t["carpeta"]] = porcarpeta.get(t["carpeta"], 0) + 1
|
||||||
|
if t["descripcion"]:
|
||||||
|
con_desc += 1
|
||||||
|
|
||||||
|
for carpeta in CARPETAS:
|
||||||
|
if carpeta in porcarpeta:
|
||||||
|
print(f" {carpeta:<13} {porcarpeta[carpeta]:>4} herramientas")
|
||||||
|
print(f"\n total {len(tools)}, con descripcion {con_desc} "
|
||||||
|
f"({100*con_desc//max(1,len(tools))} %)")
|
||||||
|
|
||||||
|
with open(SALIDA, "w") as f:
|
||||||
|
json.dump({"version": 1, "herramientas": tools}, f,
|
||||||
|
indent=2, ensure_ascii=False)
|
||||||
|
print(f"\nescrito {SALIDA}")
|
||||||
|
print("REVISALO a mano antes de usarlo: es material de terceros y algun")
|
||||||
|
print("'tool' sera un ejemplo o un exploit, no algo que quieras ofrecer.")
|
||||||
|
return 0
|
||||||
|
|
||||||
|
|
||||||
|
if __name__ == "__main__":
|
||||||
|
sys.exit(main())
|
||||||
331
config/entrenar.py
Executable file
331
config/entrenar.py
Executable file
|
|
@ -0,0 +1,331 @@
|
||||||
|
#!/usr/bin/env python3
|
||||||
|
"""Entrena el reconocimiento solo, sin que nadie hable.
|
||||||
|
|
||||||
|
python3 ~/COFRE/CODERS/JARVIS/config/entrenar.py # tanda normal
|
||||||
|
python3 ~/COFRE/CODERS/JARVIS/config/entrenar.py --rapido # una voz
|
||||||
|
python3 ~/COFRE/CODERS/JARVIS/config/entrenar.py --aplicar # guarda alias
|
||||||
|
|
||||||
|
Como funciona: por cada accion del catalogo se dice su frase en voz alta con
|
||||||
|
Piper, en varias voces y velocidades y con algo de ruido y sala, se transcribe
|
||||||
|
con el mismo whisper que usa el asistente, y se mira si la transcripcion llega
|
||||||
|
a la accion correcta. Lo que no llega se apunta como alias candidato.
|
||||||
|
|
||||||
|
Por que sirve: los fallos del reconocedor en castellano son sistematicos, no
|
||||||
|
aleatorios. "abre el correo" se oye "a ver el correo" siempre, y una tanda de
|
||||||
|
varios cientos de frases los saca casi todos de una sentada.
|
||||||
|
|
||||||
|
Que NO sustituye: esto es voz sintetica, no la suya. Sirve para las colisiones
|
||||||
|
foneticas del idioma —que son la mayoria de los fallos— pero no para su acento,
|
||||||
|
su microfono ni su habitacion. Para eso esta el registro de lo que no entiende
|
||||||
|
en el uso real, que se revisa con aprender.py. Las dos cosas se suman.
|
||||||
|
|
||||||
|
Un alias solo se propone si no choca con otra accion: si "a ver el correo"
|
||||||
|
pudiera ser dos cosas distintas, se descarta y se avisa.
|
||||||
|
"""
|
||||||
|
import argparse
|
||||||
|
import importlib.util
|
||||||
|
import json
|
||||||
|
import os
|
||||||
|
import random
|
||||||
|
import shutil
|
||||||
|
import subprocess
|
||||||
|
import sys
|
||||||
|
import tempfile
|
||||||
|
import time
|
||||||
|
from collections import defaultdict
|
||||||
|
|
||||||
|
CASA = os.path.expanduser("~")
|
||||||
|
JARVIS = os.path.join(CASA, "COFRE/CODERS/JARVIS")
|
||||||
|
CONFIG = os.path.join(CASA, ".var/app/io.github.qwersyk.Newelle/config")
|
||||||
|
APP = "io.github.qwersyk.Newelle//master"
|
||||||
|
|
||||||
|
PIPER = os.path.join(JARVIS, "voz/piper/piper")
|
||||||
|
MODELOS_VOZ = os.path.join(JARVIS, "voz/modelos")
|
||||||
|
WHISPER = os.path.join(CONFIG, "models/whisper/whisper.cpp/build/bin/whisper-cli")
|
||||||
|
MODELOS_STT = os.path.join(CONFIG, "models/whisper/whisper.cpp/models")
|
||||||
|
|
||||||
|
CATALOGO = os.path.expanduser(
|
||||||
|
"~/.local/share/flatpak/app/io.github.qwersyk.Newelle/x86_64/master/"
|
||||||
|
"active/files/share/newelle/acciones/acciones.json")
|
||||||
|
CATALOGO_FUENTE = os.path.join(JARVIS, "newelle/data/acciones/acciones.json")
|
||||||
|
PROPIO = os.path.join(CONFIG, "jarvis-acciones.json")
|
||||||
|
INFORME = os.path.join(JARVIS, "muestras/entrenamiento.json")
|
||||||
|
|
||||||
|
MOTOR = os.path.join(JARVIS, "newelle/src/utility/acciones.py")
|
||||||
|
|
||||||
|
# Voces distintas para que no aprenda los defectos de una sola, y velocidades
|
||||||
|
# distintas porque uno no habla igual con prisa que sin ella.
|
||||||
|
VOCES = ["es_ES-sharvard-medium", "es_ES-davefx-medium", "es_ES-carlfm-x_low"]
|
||||||
|
VELOCIDADES = [1.0, 0.88, 1.15]
|
||||||
|
|
||||||
|
# Un poco de sala y de ruido de fondo: en seco el reconocedor acierta mas de lo
|
||||||
|
# que acertara nunca en una habitacion de verdad, y entrenar con eso da una
|
||||||
|
# falsa sensacion de que todo va bien.
|
||||||
|
RUIDOS = [
|
||||||
|
"", # limpio
|
||||||
|
"aecho=0.8:0.7:22:0.12", # algo de sala
|
||||||
|
"volume=0.75,highpass=f=120", # mas lejos del microfono
|
||||||
|
]
|
||||||
|
|
||||||
|
|
||||||
|
def carga_motor():
|
||||||
|
spec = importlib.util.spec_from_file_location("acciones", MOTOR)
|
||||||
|
m = importlib.util.module_from_spec(spec)
|
||||||
|
spec.loader.exec_module(m)
|
||||||
|
return m
|
||||||
|
|
||||||
|
|
||||||
|
def dentro(orden, limite=900):
|
||||||
|
"""Ejecuta algo dentro del flatpak, que es donde vive whisper."""
|
||||||
|
return subprocess.run(
|
||||||
|
["flatpak", "run", "--command=bash", APP, "-c", orden],
|
||||||
|
capture_output=True, text=True, timeout=limite)
|
||||||
|
|
||||||
|
|
||||||
|
def genera(texto, voz, velocidad, ruido, destino):
|
||||||
|
crudo = tempfile.mktemp(suffix=".wav")
|
||||||
|
try:
|
||||||
|
r = subprocess.run(
|
||||||
|
[PIPER, "--model", os.path.join(MODELOS_VOZ, voz + ".onnx"),
|
||||||
|
"--length_scale", str(1 / velocidad), "--output_file", crudo],
|
||||||
|
input=texto, capture_output=True, text=True, timeout=60)
|
||||||
|
if r.returncode != 0 or not os.path.exists(crudo):
|
||||||
|
return False
|
||||||
|
filtros = "aresample=16000" + ("," + ruido if ruido else "")
|
||||||
|
subprocess.run(
|
||||||
|
["ffmpeg", "-hide_banner", "-loglevel", "error", "-i", crudo,
|
||||||
|
"-ac", "1", "-af", filtros, "-y", destino],
|
||||||
|
check=True, timeout=60)
|
||||||
|
return os.path.exists(destino)
|
||||||
|
except (OSError, subprocess.SubprocessError):
|
||||||
|
return False
|
||||||
|
finally:
|
||||||
|
if os.path.exists(crudo):
|
||||||
|
os.remove(crudo)
|
||||||
|
|
||||||
|
|
||||||
|
# Por tandas y no de una: mil frases son un cuarto de hora, y una sola llamada
|
||||||
|
# con limite de tiempo se corta a la mitad y se pierde todo lo transcrito. Por
|
||||||
|
# tandas ademas se puede ver el avance, que en algo que tarda tanto importa.
|
||||||
|
POR_TANDA = 40
|
||||||
|
|
||||||
|
|
||||||
|
def transcribe_lote(carpeta, ficheros, modelo="base", hilos=8):
|
||||||
|
"""Transcribe una lista de wav. Devuelve {fichero: texto}."""
|
||||||
|
salida = {}
|
||||||
|
ini = time.time()
|
||||||
|
for i in range(0, len(ficheros), POR_TANDA):
|
||||||
|
tanda = ficheros[i:i + POR_TANDA]
|
||||||
|
lista = " ".join(f'"{carpeta}/{n}"' for n in tanda)
|
||||||
|
orden = (
|
||||||
|
f'for f in {lista}; do '
|
||||||
|
f' echo "### $(basename "$f")"; '
|
||||||
|
f' {WHISPER} -m {MODELOS_STT}/ggml-{modelo}.bin -l es -nt -t {hilos} '
|
||||||
|
f' -f "$f" 2>/dev/null | tr "\\n" " "; echo; '
|
||||||
|
f'done')
|
||||||
|
try:
|
||||||
|
r = dentro(orden)
|
||||||
|
except subprocess.SubprocessError as e:
|
||||||
|
print(f" tanda {i//POR_TANDA + 1} fallo: {e}", flush=True)
|
||||||
|
continue
|
||||||
|
|
||||||
|
actual = None
|
||||||
|
for linea in r.stdout.splitlines():
|
||||||
|
if linea.startswith("### "):
|
||||||
|
actual = linea[4:].strip()
|
||||||
|
elif actual:
|
||||||
|
salida[actual] = linea.strip()
|
||||||
|
actual = None
|
||||||
|
|
||||||
|
hechas = min(i + POR_TANDA, len(ficheros))
|
||||||
|
queda = (time.time() - ini) / hechas * (len(ficheros) - hechas)
|
||||||
|
print(f" transcritas {hechas}/{len(ficheros)} "
|
||||||
|
f"({queda/60:.0f} min restantes)", flush=True)
|
||||||
|
return salida
|
||||||
|
|
||||||
|
|
||||||
|
def main():
|
||||||
|
ap = argparse.ArgumentParser()
|
||||||
|
ap.add_argument("--rapido", action="store_true", help="una voz y una velocidad")
|
||||||
|
ap.add_argument("--aplicar", action="store_true", help="guardar los alias encontrados")
|
||||||
|
ap.add_argument("--tope", type=int, default=0, help="limitar acciones (para probar)")
|
||||||
|
ap.add_argument("--reanudar", action="store_true",
|
||||||
|
help="usar los wav ya generados en vez de rehacerlos")
|
||||||
|
args = ap.parse_args()
|
||||||
|
|
||||||
|
for ruta, que in ((PIPER, "piper"), (WHISPER, "whisper")):
|
||||||
|
if not os.path.exists(ruta):
|
||||||
|
print(f"falta {que}: {ruta}")
|
||||||
|
return 1
|
||||||
|
|
||||||
|
catalogo = CATALOGO if os.path.exists(CATALOGO) else CATALOGO_FUENTE
|
||||||
|
with open(catalogo) as f:
|
||||||
|
acciones = json.load(f)["acciones"]
|
||||||
|
if args.tope:
|
||||||
|
acciones = acciones[:args.tope]
|
||||||
|
|
||||||
|
voces = VOCES[:1] if args.rapido else VOCES
|
||||||
|
velocidades = VELOCIDADES[:1] if args.rapido else VELOCIDADES
|
||||||
|
ruidos = RUIDOS[:1] if args.rapido else RUIDOS
|
||||||
|
|
||||||
|
motor = carga_motor()
|
||||||
|
cat = motor.Catalogo([catalogo])
|
||||||
|
|
||||||
|
# Las acciones que esperan argumento hay que decirlas CON argumento. Sin el,
|
||||||
|
# el motor las rechaza a proposito —"busca el fichero" a secas no es una
|
||||||
|
# orden— y contarlo como fallo del reconocedor es medir mal: en la primera
|
||||||
|
# tanda hundio el resultado del 48 %, con una cuarta parte de las frases
|
||||||
|
# condenadas de antemano.
|
||||||
|
RELLENOS = ["notas", "el informe de ayer", "documentos"]
|
||||||
|
|
||||||
|
# Solo la frase principal de cada accion: las variantes ya estan escritas a
|
||||||
|
# mano y lo que se busca aqui es como se oye la que uno diria de verdad.
|
||||||
|
trabajos = []
|
||||||
|
for a in acciones:
|
||||||
|
if not a["frases"]:
|
||||||
|
continue
|
||||||
|
frase = a["frases"][0]
|
||||||
|
if a.get("captura"):
|
||||||
|
frase = frase + " " + random.choice(RELLENOS)
|
||||||
|
for voz in voces:
|
||||||
|
for vel in velocidades:
|
||||||
|
trabajos.append((a["id"], frase, voz, vel,
|
||||||
|
random.choice(ruidos)))
|
||||||
|
|
||||||
|
total = len(trabajos)
|
||||||
|
print(f"{len(acciones)} acciones · {len(voces)} voces · "
|
||||||
|
f"{len(velocidades)} velocidades = {total} frases habladas")
|
||||||
|
print("esto tarda; se puede dejar corriendo\n")
|
||||||
|
|
||||||
|
carpeta = os.path.join(CONFIG, "entrenamiento")
|
||||||
|
|
||||||
|
indice = {f"{n:05d}.wav": (ident, frase, voz, vel)
|
||||||
|
for n, (ident, frase, voz, vel, _) in enumerate(trabajos, 1)}
|
||||||
|
|
||||||
|
if args.reanudar and os.path.isdir(carpeta):
|
||||||
|
indice = {n: v for n, v in indice.items()
|
||||||
|
if os.path.exists(os.path.join(carpeta, n))}
|
||||||
|
print(f"reanudando con {len(indice)} frases ya generadas\n", flush=True)
|
||||||
|
else:
|
||||||
|
shutil.rmtree(carpeta, ignore_errors=True)
|
||||||
|
os.makedirs(carpeta, exist_ok=True)
|
||||||
|
vivos, ini = {}, time.time()
|
||||||
|
for n, (ident, frase, voz, vel, ruido) in enumerate(trabajos, 1):
|
||||||
|
nombre = f"{n:05d}.wav"
|
||||||
|
if genera(frase, voz, vel, ruido, os.path.join(carpeta, nombre)):
|
||||||
|
vivos[nombre] = (ident, frase, voz, vel)
|
||||||
|
if n % 25 == 0 or n == total:
|
||||||
|
queda = (time.time() - ini) / n * (total - n)
|
||||||
|
print(f" generadas {n}/{total} ({queda/60:.0f} min restantes)",
|
||||||
|
flush=True)
|
||||||
|
indice = vivos
|
||||||
|
|
||||||
|
print(f"\ntranscribiendo {len(indice)} frases...", flush=True)
|
||||||
|
textos = transcribe_lote(carpeta, sorted(indice))
|
||||||
|
print(f"transcritas {len(textos)}\n", flush=True)
|
||||||
|
|
||||||
|
aciertos = 0
|
||||||
|
candidatos = defaultdict(lambda: defaultdict(int))
|
||||||
|
for nombre, (ident, frase, voz, vel) in indice.items():
|
||||||
|
oido = textos.get(nombre, "").strip()
|
||||||
|
if not oido:
|
||||||
|
continue
|
||||||
|
encontrada, _ = cat.busca(oido)
|
||||||
|
if encontrada is not None and encontrada.id == ident:
|
||||||
|
aciertos += 1
|
||||||
|
else:
|
||||||
|
candidatos[ident][motor.normaliza(oido)] += 1
|
||||||
|
|
||||||
|
evaluadas = sum(1 for n in indice if textos.get(n))
|
||||||
|
print(f"aciertos: {aciertos}/{evaluadas} "
|
||||||
|
f"({100*aciertos/max(1,evaluadas):.0f} %)\n")
|
||||||
|
|
||||||
|
# Un alias solo vale si no puede ser otra cosa. Si la misma frase mal oida
|
||||||
|
# aparece en dos acciones, elegir una seria peor que no hacer nada.
|
||||||
|
duenos = defaultdict(set)
|
||||||
|
for ident, frases in candidatos.items():
|
||||||
|
for f in frases:
|
||||||
|
duenos[f].add(ident)
|
||||||
|
|
||||||
|
propuestos, descartados = defaultdict(list), []
|
||||||
|
for ident, frases in candidatos.items():
|
||||||
|
for f, veces in sorted(frases.items(), key=lambda x: -x[1]):
|
||||||
|
if len(duenos[f]) > 1:
|
||||||
|
descartados.append((f, sorted(duenos[f])))
|
||||||
|
continue
|
||||||
|
if len(f.split()) < 2: # una palabra suelta engancha de todo
|
||||||
|
continue
|
||||||
|
# Si lo oido no se parece a lo dicho, es que el reconocedor se
|
||||||
|
# perdio del todo, no que haya una confusion fonetica estable.
|
||||||
|
# Guardarlo como alias meteria una frase arbitraria en el catalogo
|
||||||
|
# y algun dia enganchara una conversacion.
|
||||||
|
original = next((a["frases"][0] for a in acciones if a["id"] == ident), "")
|
||||||
|
if motor.parecido(f, motor.normaliza(original)) < 0.55:
|
||||||
|
descartados.append((f, [ident + " (irreconocible)"]))
|
||||||
|
continue
|
||||||
|
if cat.busca(f)[0] is not None: # ya lo coge otra cosa
|
||||||
|
continue
|
||||||
|
propuestos[ident].append((f, veces))
|
||||||
|
|
||||||
|
if propuestos:
|
||||||
|
print("alias que faltan (frase mal oida -> accion):")
|
||||||
|
for ident, lista in sorted(propuestos.items()):
|
||||||
|
for f, veces in lista[:3]:
|
||||||
|
print(f' "{f}" -> {ident} ({veces}x)')
|
||||||
|
else:
|
||||||
|
print("no falta ningun alias: todo lo dicho llega a su accion")
|
||||||
|
|
||||||
|
if descartados:
|
||||||
|
print(f"\n{len(descartados)} descartados por ambiguos "
|
||||||
|
f"(la misma frase encaja en dos acciones):")
|
||||||
|
for f, ids in descartados[:5]:
|
||||||
|
print(f' "{f}" -> {", ".join(ids)}')
|
||||||
|
|
||||||
|
os.makedirs(os.path.dirname(INFORME), exist_ok=True)
|
||||||
|
with open(INFORME, "w") as f:
|
||||||
|
json.dump({
|
||||||
|
"frases": evaluadas, "aciertos": aciertos,
|
||||||
|
"propuestos": {k: v for k, v in propuestos.items()},
|
||||||
|
"ambiguos": descartados,
|
||||||
|
}, f, indent=2, ensure_ascii=False)
|
||||||
|
print(f"\ninforme en {INFORME}")
|
||||||
|
|
||||||
|
if args.aplicar and propuestos:
|
||||||
|
guarda(propuestos, catalogo)
|
||||||
|
elif propuestos:
|
||||||
|
print("para guardarlos: vuelve a lanzarlo con --aplicar")
|
||||||
|
|
||||||
|
print(f"los wav se quedan en {carpeta} por si hay que repasar algo")
|
||||||
|
return 0
|
||||||
|
|
||||||
|
|
||||||
|
def guarda(propuestos, catalogo):
|
||||||
|
with open(catalogo) as f:
|
||||||
|
original = {a["id"]: a for a in json.load(f)["acciones"]}
|
||||||
|
try:
|
||||||
|
with open(PROPIO) as f:
|
||||||
|
propio = json.load(f)
|
||||||
|
except (OSError, json.JSONDecodeError):
|
||||||
|
propio = {"version": 1, "acciones": []}
|
||||||
|
|
||||||
|
porid = {a["id"]: a for a in propio.get("acciones", [])}
|
||||||
|
n = 0
|
||||||
|
for ident, lista in propuestos.items():
|
||||||
|
entrada = porid.get(ident)
|
||||||
|
if entrada is None:
|
||||||
|
entrada = dict(original[ident])
|
||||||
|
porid[ident] = entrada
|
||||||
|
propio.setdefault("acciones", []).append(entrada)
|
||||||
|
for frase, _ in lista:
|
||||||
|
if frase not in entrada["frases"]:
|
||||||
|
entrada["frases"].append(frase)
|
||||||
|
n += 1
|
||||||
|
|
||||||
|
with open(PROPIO, "w") as f:
|
||||||
|
json.dump(propio, f, indent=2, ensure_ascii=False)
|
||||||
|
print(f"{n} alias guardados en {PROPIO}")
|
||||||
|
print("se aplican al abrir la pestaña JARVIS otra vez")
|
||||||
|
|
||||||
|
|
||||||
|
if __name__ == "__main__":
|
||||||
|
sys.exit(main())
|
||||||
156
config/indexar.py
Executable file
156
config/indexar.py
Executable file
|
|
@ -0,0 +1,156 @@
|
||||||
|
#!/usr/bin/env python3
|
||||||
|
"""Prepara el corpus de COFRE para que JARVIS lo consulte.
|
||||||
|
|
||||||
|
python3 ~/COFRE/CODERS/JARVIS/config/indexar.py # ver que entraria
|
||||||
|
python3 ~/COFRE/CODERS/JARVIS/config/indexar.py --hacerlo # copiarlo
|
||||||
|
python3 ~/COFRE/CODERS/JARVIS/config/indexar.py --hacerlo --solo-notas
|
||||||
|
|
||||||
|
Que hace: recorre las carpetas de COFRE, se queda SOLO con lo que es
|
||||||
|
conocimiento y lo copia a la carpeta de documentos de Newelle, que es de donde
|
||||||
|
lee el RAG. Despues hay que pulsar "Update Index" en los ajustes de la app.
|
||||||
|
|
||||||
|
Por que hace falta filtrar. Medido en esta maquina:
|
||||||
|
|
||||||
|
COFRE entero (las nueve carpetas) ~120 GB
|
||||||
|
de eso, ISOs, maquinas virtuales,
|
||||||
|
APKs, audio y un diccionario de
|
||||||
|
contraseñas de 9,1 GB ~100 GB
|
||||||
|
texto de menos de 100 KB 76,6 MB en 35 098 ficheros
|
||||||
|
quitando exploitdb 20,8 MB en 4 548 ficheros
|
||||||
|
|
||||||
|
exploitdb se queda fuera a proposito: son 32 000 ficheros que aplastarian el
|
||||||
|
indice y enterrarian tus notas, y ademas NO hacen falta ahi. Tienes
|
||||||
|
`searchsploit` instalado, que busca en ellos de forma exacta e instantanea. Un
|
||||||
|
indice de vectores es peor que una busqueda exacta cuando lo que buscas es el
|
||||||
|
nombre literal de un exploit.
|
||||||
|
|
||||||
|
Los nombres se aplanan conservando la ruta —PENTESTERS__OSCP__nmap.md— para que
|
||||||
|
al responder se pueda ver de donde salio cada cosa.
|
||||||
|
"""
|
||||||
|
import argparse
|
||||||
|
import hashlib
|
||||||
|
import os
|
||||||
|
import shutil
|
||||||
|
import sys
|
||||||
|
|
||||||
|
COFRE = os.path.expanduser("~/COFRE")
|
||||||
|
DESTINO = os.path.expanduser(
|
||||||
|
"~/.var/app/io.github.qwersyk.Newelle/config/models/documents")
|
||||||
|
|
||||||
|
CARPETAS = ["CODERS", "PENTESTERS", "AUTOMATAS", "DOSER", "HARD-WARERS",
|
||||||
|
"PHISHERS", "PROTECTORS", "REVERSERS", "SNEAKERS"]
|
||||||
|
|
||||||
|
EXTENSIONES = {".md", ".txt", ".rst", ".adoc"}
|
||||||
|
|
||||||
|
# Por tamaño: por encima de esto ya no es prosa, son datos. El diccionario
|
||||||
|
# kaonashi.txt son 9,1 GB de contraseñas.
|
||||||
|
TAMANO_MAXIMO = 100 * 1024
|
||||||
|
TAMANO_MINIMO = 120 # menos de esto no dice nada
|
||||||
|
|
||||||
|
# Carpetas que no aportan conocimiento y si mucho ruido
|
||||||
|
FUERA = {
|
||||||
|
"exploitdb", # 32 000 ficheros; para eso esta searchsploit
|
||||||
|
"node_modules", ".git", "venv", ".venv", "site-packages", "__pycache__",
|
||||||
|
"isos", "VirtualBox VMs", "build", "dist", ".cache", "target",
|
||||||
|
"flatpak-app", ".flatpak-builder", "rag_cache", "entrenamiento",
|
||||||
|
}
|
||||||
|
|
||||||
|
# Ficheros que son plantilla o licencia y solo ensucian
|
||||||
|
NOMBRES_FUERA = {"LICENSE.txt", "LICENSE.md", "CHANGELOG.md", "requirements.txt"}
|
||||||
|
|
||||||
|
|
||||||
|
def interesa(ruta: str, nombre: str) -> bool:
|
||||||
|
ext = os.path.splitext(nombre)[1].lower()
|
||||||
|
if ext not in EXTENSIONES or nombre in NOMBRES_FUERA:
|
||||||
|
return False
|
||||||
|
try:
|
||||||
|
tam = os.path.getsize(ruta)
|
||||||
|
except OSError:
|
||||||
|
return False
|
||||||
|
return TAMANO_MINIMO <= tam <= TAMANO_MAXIMO
|
||||||
|
|
||||||
|
|
||||||
|
def recorre(solo_notas: bool):
|
||||||
|
"""Devuelve [(origen, nombre_plano)] de todo lo que merece indexarse."""
|
||||||
|
salida = []
|
||||||
|
for carpeta in CARPETAS:
|
||||||
|
raiz = os.path.join(COFRE, carpeta)
|
||||||
|
if not os.path.isdir(raiz):
|
||||||
|
continue
|
||||||
|
for dirpath, dirnames, ficheros in os.walk(raiz):
|
||||||
|
dirnames[:] = [d for d in dirnames
|
||||||
|
if d not in FUERA and not d.startswith(".")]
|
||||||
|
for nombre in ficheros:
|
||||||
|
if solo_notas and not nombre.lower().endswith(".md"):
|
||||||
|
continue
|
||||||
|
origen = os.path.join(dirpath, nombre)
|
||||||
|
if not interesa(origen, nombre):
|
||||||
|
continue
|
||||||
|
relativa = os.path.relpath(origen, COFRE)
|
||||||
|
plano = relativa.replace(os.sep, "__")
|
||||||
|
if len(plano) > 180: # algunos nombres son kilometricos
|
||||||
|
corto = hashlib.sha256(plano.encode()).hexdigest()[:8]
|
||||||
|
plano = plano[:150] + "_" + corto + os.path.splitext(plano)[1]
|
||||||
|
salida.append((origen, plano))
|
||||||
|
return salida
|
||||||
|
|
||||||
|
|
||||||
|
def main():
|
||||||
|
ap = argparse.ArgumentParser()
|
||||||
|
ap.add_argument("--hacerlo", action="store_true", help="copiar de verdad")
|
||||||
|
ap.add_argument("--solo-notas", action="store_true",
|
||||||
|
help="solo .md, sin los .txt sueltos")
|
||||||
|
ap.add_argument("--limpiar", action="store_true",
|
||||||
|
help="vaciar el destino antes de copiar")
|
||||||
|
args = ap.parse_args()
|
||||||
|
|
||||||
|
print("recorriendo COFRE...", flush=True)
|
||||||
|
lista = recorre(args.solo_notas)
|
||||||
|
|
||||||
|
porcarpeta, total = {}, 0
|
||||||
|
for origen, _ in lista:
|
||||||
|
carpeta = os.path.relpath(origen, COFRE).split(os.sep)[0]
|
||||||
|
tam = os.path.getsize(origen)
|
||||||
|
n, b = porcarpeta.get(carpeta, (0, 0))
|
||||||
|
porcarpeta[carpeta] = (n + 1, b + tam)
|
||||||
|
total += tam
|
||||||
|
|
||||||
|
print(f"\n{'carpeta':<14}{'ficheros':>10}{'texto':>12}")
|
||||||
|
for carpeta in CARPETAS:
|
||||||
|
if carpeta in porcarpeta:
|
||||||
|
n, b = porcarpeta[carpeta]
|
||||||
|
print(f"{carpeta:<14}{n:>10}{b/1048576:>10.1f} MB")
|
||||||
|
print(f"{'TOTAL':<14}{len(lista):>10}{total/1048576:>10.1f} MB")
|
||||||
|
print(f"\nfragmentos de 256 tokens: ~{total // 1024}")
|
||||||
|
|
||||||
|
if not args.hacerlo:
|
||||||
|
print("\nesto es solo el recuento; para copiarlo: --hacerlo")
|
||||||
|
return 0
|
||||||
|
|
||||||
|
if args.limpiar and os.path.isdir(DESTINO):
|
||||||
|
shutil.rmtree(DESTINO)
|
||||||
|
os.makedirs(DESTINO, exist_ok=True)
|
||||||
|
|
||||||
|
copiados = saltados = 0
|
||||||
|
for origen, plano in lista:
|
||||||
|
destino = os.path.join(DESTINO, plano)
|
||||||
|
try:
|
||||||
|
# solo si cambio: reindexar 4500 ficheros iguales no tiene sentido
|
||||||
|
if (os.path.exists(destino)
|
||||||
|
and os.path.getmtime(destino) >= os.path.getmtime(origen)):
|
||||||
|
saltados += 1
|
||||||
|
continue
|
||||||
|
shutil.copy2(origen, destino)
|
||||||
|
copiados += 1
|
||||||
|
except OSError as e:
|
||||||
|
print(f" no se pudo copiar {plano}: {e}")
|
||||||
|
|
||||||
|
print(f"\n{copiados} copiados, {saltados} ya estaban al dia")
|
||||||
|
print(f"en {DESTINO}")
|
||||||
|
print("\nAhora, en Newelle: Ajustes -> RAG -> Update Index")
|
||||||
|
print("La primera vez tarda; son unos 21 000 fragmentos.")
|
||||||
|
return 0
|
||||||
|
|
||||||
|
|
||||||
|
if __name__ == "__main__":
|
||||||
|
sys.exit(main())
|
||||||
4197
config/jarvis-herramientas.json
Normal file
4197
config/jarvis-herramientas.json
Normal file
File diff suppressed because it is too large
Load diff
58
config/jarvis-piper.sh
Executable file
58
config/jarvis-piper.sh
Executable file
|
|
@ -0,0 +1,58 @@
|
||||||
|
#!/usr/bin/env bash
|
||||||
|
# Voz de JARVIS con Piper: castellano de España, no latinoamericano.
|
||||||
|
#
|
||||||
|
# jarvis-piper.sh <fichero.wav> <texto>
|
||||||
|
#
|
||||||
|
# Kokoro, que es lo que trae Newelle, no tiene ni una voz de España: sus dos
|
||||||
|
# masculinas en español (em_alex, em_santa) suenan latinas. Piper si las tiene,
|
||||||
|
# es libre y corre local. Se invoca desde el handler custom_command, que ya
|
||||||
|
# ejecuta en el host.
|
||||||
|
#
|
||||||
|
# El descenso de tono se hace aqui y no en la cadena de la app porque alli se
|
||||||
|
# usa asetrate, que necesita saber la frecuencia de muestreo: esta calculada
|
||||||
|
# para los 24 kHz de Kokoro y Piper saca 22050, asi que aplicaria una bajada
|
||||||
|
# distinta de la pedida. Aqui se usa rubberband, que trabaja en semitonos y le
|
||||||
|
# da igual la frecuencia. Existe en el ffmpeg del sistema pero no en el del
|
||||||
|
# flatpak, y este script ya corre fuera.
|
||||||
|
#
|
||||||
|
# Ajustes por entorno:
|
||||||
|
# JARVIS_PIPER_VOZ es_ES-sharvard-medium (defecto) | es_ES-davefx-medium
|
||||||
|
# | es_ES-carlfm-x_low
|
||||||
|
# JARVIS_PIPER_TONO 0.90 (defecto). 1.0 no toca el tono; por debajo de
|
||||||
|
# 0.85 empieza a sonar artificial.
|
||||||
|
|
||||||
|
set -uo pipefail
|
||||||
|
|
||||||
|
# La raiz se deduce de donde esta este fichero, no del $HOME de nadie: asi el
|
||||||
|
# arbol se puede mover o clonar en otra maquina y sigue funcionando sin editar
|
||||||
|
# rutas. `cd -P` resuelve enlaces simbolicos, que el lanzador de escritorio
|
||||||
|
# puede invocarlo por uno.
|
||||||
|
RAIZ=$(cd -P "$(dirname "${BASH_SOURCE[0]:-$0}")/.." && pwd)
|
||||||
|
BASE=$RAIZ/voz
|
||||||
|
VOZ=${JARVIS_PIPER_VOZ:-es_ES-sharvard-medium}
|
||||||
|
TONO=${JARVIS_PIPER_TONO:-0.90}
|
||||||
|
|
||||||
|
SALIDA=${1:-}
|
||||||
|
TEXTO=${2:-}
|
||||||
|
|
||||||
|
[ -n "$SALIDA" ] || { echo "falta el fichero de salida" >&2; exit 1; }
|
||||||
|
[ -n "$TEXTO" ] || { echo "sin texto que decir" >&2; exit 1; }
|
||||||
|
|
||||||
|
MODELO=$BASE/modelos/$VOZ.onnx
|
||||||
|
[ -f "$MODELO" ] || { echo "no esta el modelo $MODELO" >&2; exit 1; }
|
||||||
|
|
||||||
|
CRUDO=$(mktemp --suffix=.wav)
|
||||||
|
trap 'rm -f "$CRUDO"' EXIT
|
||||||
|
|
||||||
|
printf '%s' "$TEXTO" | "$BASE/piper/piper" \
|
||||||
|
--model "$MODELO" --output_file "$CRUDO" 2>/dev/null
|
||||||
|
|
||||||
|
[ -s "$CRUDO" ] || { echo "piper no genero audio" >&2; exit 1; }
|
||||||
|
|
||||||
|
if [ "$TONO" = "1.0" ] || ! command -v ffmpeg >/dev/null; then
|
||||||
|
cp "$CRUDO" "$SALIDA"
|
||||||
|
else
|
||||||
|
ffmpeg -hide_banner -loglevel error -i "$CRUDO" \
|
||||||
|
-af "rubberband=pitch=$TONO" -y "$SALIDA" 2>/dev/null \
|
||||||
|
|| cp "$CRUDO" "$SALIDA"
|
||||||
|
fi
|
||||||
46
config/jarvis-voz.sh
Executable file
46
config/jarvis-voz.sh
Executable file
|
|
@ -0,0 +1,46 @@
|
||||||
|
#!/usr/bin/env bash
|
||||||
|
# Voz de JARVIS con la clonada (XTTS-v2) servida desde cache.
|
||||||
|
#
|
||||||
|
# jarvis-voz.sh <fichero.wav> <texto>
|
||||||
|
#
|
||||||
|
# Si el texto esta pre-generado en cache_voz/, lo sirve al instante (un cp, sin
|
||||||
|
# tocar GPU). Si no, cae a Piper. La clave es sha1(texto normalizado), la misma
|
||||||
|
# que calcula generar_cache_voz.py -> los aciertos son exactos.
|
||||||
|
#
|
||||||
|
# El clon ya trae el tono correcto, asi que en un acierto NO se aplica el
|
||||||
|
# descenso de tono de Piper; solo se copia. En un fallo, Piper hace lo suyo
|
||||||
|
# (incluido su rubberband) como hasta ahora.
|
||||||
|
set -uo pipefail
|
||||||
|
|
||||||
|
# La raiz se deduce de donde esta este fichero, no del $HOME de nadie: asi el
|
||||||
|
# arbol se puede mover o clonar en otra maquina y sigue funcionando sin editar
|
||||||
|
# rutas. `cd -P` resuelve enlaces simbolicos, que el lanzador de escritorio
|
||||||
|
# puede invocarlo por uno.
|
||||||
|
RAIZ=$(cd -P "$(dirname "${BASH_SOURCE[0]:-$0}")/.." && pwd)
|
||||||
|
BASE=$RAIZ/voz
|
||||||
|
CACHE=$BASE/cache_voz
|
||||||
|
PIPER=$RAIZ/config/jarvis-piper.sh
|
||||||
|
|
||||||
|
SALIDA=${1:-}
|
||||||
|
TEXTO=${2:-}
|
||||||
|
|
||||||
|
[ -n "$SALIDA" ] || { echo "falta el fichero de salida" >&2; exit 1; }
|
||||||
|
[ -n "$TEXTO" ] || { echo "sin texto que decir" >&2; exit 1; }
|
||||||
|
|
||||||
|
# clave = sha1(texto con espacios colapsados y recortado), identica a la de
|
||||||
|
# Python: re.sub(r'\s+',' ',t).strip() -> sha1(utf-8)
|
||||||
|
T=$(printf '%s' "$TEXTO" | tr -s '[:space:]' ' ' | sed 's/^ //; s/ $//')
|
||||||
|
KEY=$(printf '%s' "$T" | sha1sum | cut -d' ' -f1)
|
||||||
|
HIT=$CACHE/$KEY.wav
|
||||||
|
|
||||||
|
if [ -f "$HIT" ]; then
|
||||||
|
cp -f "$HIT" "$SALIDA"
|
||||||
|
exit 0
|
||||||
|
fi
|
||||||
|
|
||||||
|
# fallo de cache -> registrar la frase (normalizada) para calentar la cache
|
||||||
|
# luego con la voz clonada, y de momento reescribir siglas + Piper.
|
||||||
|
printf '%s\n' "$T" >> "$BASE/misses.log" 2>/dev/null || true
|
||||||
|
TEXTO2=$(python3 "$BASE/pronuncia.py" "$TEXTO" 2>/dev/null)
|
||||||
|
[ -n "$TEXTO2" ] || TEXTO2=$TEXTO
|
||||||
|
exec "$PIPER" "$SALIDA" "$TEXTO2"
|
||||||
484
config/mejora_nocturna.py
Executable file
484
config/mejora_nocturna.py
Executable file
|
|
@ -0,0 +1,484 @@
|
||||||
|
#!/usr/bin/env python3
|
||||||
|
"""Bucle de mejora que corre solo, ronda tras ronda, y se protege de empeorar.
|
||||||
|
|
||||||
|
python3 ~/COFRE/CODERS/JARVIS/config/mejora_nocturna.py # hasta la mañana
|
||||||
|
python3 ~/COFRE/CODERS/JARVIS/config/mejora_nocturna.py --horas 2 # un rato
|
||||||
|
python3 ~/COFRE/CODERS/JARVIS/config/mejora_nocturna.py --ronda # una sola
|
||||||
|
|
||||||
|
Que hace en cada ronda:
|
||||||
|
1. Dice en voz alta (Piper) las frases del catalogo, en varias voces,
|
||||||
|
velocidades y con ruido y sala aleatorios, distintos cada ronda.
|
||||||
|
2. Las transcribe con el mismo Whisper del asistente.
|
||||||
|
3. Mira que porcentaje llega a su accion. Ese es el marcador de la ronda.
|
||||||
|
4. De lo que NO llega, se queda con los fallos SISTEMATICOS (repetidos) y
|
||||||
|
SIN AMBIGUEDAD (que no puedan ser dos acciones), y los propone como alias.
|
||||||
|
5. GUARDA: antes de aplicar nada, comprueba en una copia que
|
||||||
|
a) el acierto sube, y
|
||||||
|
b) la conversacion normal SIGUE yendo al modelo (no se cuela ninguna).
|
||||||
|
Solo si las dos cosas se cumplen, aplica los alias de verdad.
|
||||||
|
6. Copia de seguridad del catalogo antes de tocarlo, y todo al registro.
|
||||||
|
|
||||||
|
Por que es seguro dejarlo sin mirar: nunca aplica algo que baje el acierto ni
|
||||||
|
que haga que una frase de charla acabe ejecutando un comando. Si una ronda
|
||||||
|
empeorara, revierte. Y cada cambio queda respaldado, asi que siempre se puede
|
||||||
|
volver atras a mano.
|
||||||
|
|
||||||
|
Que NO hace: reentrenar el modelo (no cabe en 4 GB de VRAM) ni tocar Whisper o
|
||||||
|
Piper. Mejora la capa de emparejamiento —alias y umbrales—, que es donde estan
|
||||||
|
casi todos los fallos y donde una mejora es inmediata, legible y reversible.
|
||||||
|
|
||||||
|
En marcha se puede seguir con:
|
||||||
|
tail -f ~/COFRE/CODERS/JARVIS/muestras/mejora/registro.log
|
||||||
|
cat ~/COFRE/CODERS/JARVIS/muestras/mejora/marcador.json
|
||||||
|
"""
|
||||||
|
import argparse
|
||||||
|
import importlib.util
|
||||||
|
import json
|
||||||
|
import os
|
||||||
|
import random
|
||||||
|
import shutil
|
||||||
|
import subprocess
|
||||||
|
import sys
|
||||||
|
import tempfile
|
||||||
|
import time
|
||||||
|
from collections import defaultdict
|
||||||
|
|
||||||
|
CASA = os.path.expanduser("~")
|
||||||
|
JARVIS = os.path.join(CASA, "COFRE/CODERS/JARVIS")
|
||||||
|
CONFIG = os.path.join(CASA, ".var/app/io.github.qwersyk.Newelle/config")
|
||||||
|
APP = "io.github.qwersyk.Newelle//master"
|
||||||
|
|
||||||
|
PIPER = os.path.join(JARVIS, "voz/piper/piper")
|
||||||
|
MODELOS_VOZ = os.path.join(JARVIS, "voz/modelos")
|
||||||
|
WHISPER = os.path.join(CONFIG, "models/whisper/whisper.cpp/build/bin/whisper-cli")
|
||||||
|
MODELOS_STT = os.path.join(CONFIG, "models/whisper/whisper.cpp/models")
|
||||||
|
|
||||||
|
CATALOGO = os.path.expanduser(
|
||||||
|
"~/.local/share/flatpak/app/io.github.qwersyk.Newelle/x86_64/master/"
|
||||||
|
"active/files/share/newelle/acciones/acciones.json")
|
||||||
|
CATALOGO_FUENTE = os.path.join(JARVIS, "newelle/data/acciones/acciones.json")
|
||||||
|
PROPIO = os.path.join(CONFIG, "jarvis-acciones.json")
|
||||||
|
MOTOR = os.path.join(JARVIS, "newelle/src/utility/acciones.py")
|
||||||
|
|
||||||
|
SALA = os.path.join(JARVIS, "muestras/mejora")
|
||||||
|
REGISTRO = os.path.join(SALA, "registro.log")
|
||||||
|
MARCADOR = os.path.join(SALA, "marcador.json")
|
||||||
|
COPIAS = os.path.join(SALA, "copias")
|
||||||
|
WAVS = os.path.join(CONFIG, "mejora_wavs")
|
||||||
|
|
||||||
|
VOCES = ["es_ES-sharvard-medium", "es_ES-davefx-medium", "es_ES-carlfm-x_low"]
|
||||||
|
# Cada ronda escoge una rejilla distinta de velocidades y ruidos, para que no
|
||||||
|
# se estanque midiendo siempre lo mismo y siga sacando fallos raros.
|
||||||
|
VELOCIDADES = [0.85, 0.92, 1.0, 1.08, 1.18]
|
||||||
|
RUIDOS = [
|
||||||
|
"",
|
||||||
|
"aecho=0.8:0.7:22:0.12",
|
||||||
|
"volume=0.72,highpass=f=120",
|
||||||
|
"aecho=0.6:0.5:35:0.2,volume=0.8",
|
||||||
|
"highpass=f=150,lowpass=f=6500", # microfono cutre
|
||||||
|
"volume=0.65", # lejos
|
||||||
|
]
|
||||||
|
RELLENOS = ["notas", "el informe", "documentos", "la reunion de ayer", "gatos"]
|
||||||
|
|
||||||
|
# Frases de charla que NUNCA deben acabar en una accion. Es el guardarrail: si
|
||||||
|
# despues de aplicar alias alguna se cuela, la ronda se revierte.
|
||||||
|
CHARLA = [
|
||||||
|
"cuentame un chiste sobre gatos", "que opinas del proyecto",
|
||||||
|
"hola que tal estas", "gracias por todo", "no se que hacer con esto",
|
||||||
|
"me parece que esto no funciona bien", "buenas tardes que tal",
|
||||||
|
"cuentame algo interesante", "estoy cansado de programar",
|
||||||
|
"que raro todo esto la verdad", "a ver si esto va mejor ahora",
|
||||||
|
"pues no tengo ni idea de que decir", "vale perfecto muchas gracias",
|
||||||
|
"oye una cosa que te queria preguntar",
|
||||||
|
]
|
||||||
|
|
||||||
|
TOPE_ALIAS_POR_ACCION = 25 # que una accion no acumule cientos de alias
|
||||||
|
UMBRAL_SISTEMATICO = 2 # veces que hay que fallar igual para creerselo
|
||||||
|
DRY_PARA_PARAR = 6 # rondas seguidas sin nada nuevo -> converge
|
||||||
|
|
||||||
|
|
||||||
|
def log(msg):
|
||||||
|
linea = f"[{time.strftime('%H:%M:%S')}] {msg}"
|
||||||
|
print(linea, flush=True)
|
||||||
|
try:
|
||||||
|
with open(REGISTRO, "a") as f:
|
||||||
|
f.write(linea + "\n")
|
||||||
|
except OSError:
|
||||||
|
pass
|
||||||
|
|
||||||
|
|
||||||
|
def disco_libre_gb() -> float:
|
||||||
|
"""GB libres en la particion del home. Guardarrail: aunque el bucle apenas
|
||||||
|
ocupa 3 MB por ronda y los limpia, si algo mas llenara el disco durante la
|
||||||
|
noche conviene parar en vez de dejar el sistema sin espacio."""
|
||||||
|
try:
|
||||||
|
s = os.statvfs(CASA)
|
||||||
|
return s.f_bavail * s.f_frsize / 1e9
|
||||||
|
except OSError:
|
||||||
|
return 999.0
|
||||||
|
|
||||||
|
|
||||||
|
def carga_motor():
|
||||||
|
# se recarga cada ronda: el catalogo propio cambia y el motor debe verlo
|
||||||
|
spec = importlib.util.spec_from_file_location("acciones", MOTOR)
|
||||||
|
m = importlib.util.module_from_spec(spec)
|
||||||
|
spec.loader.exec_module(m)
|
||||||
|
return m
|
||||||
|
|
||||||
|
|
||||||
|
def dentro(orden, limite=1200):
|
||||||
|
return subprocess.run(
|
||||||
|
["flatpak", "run", "--command=bash", APP, "-c", orden],
|
||||||
|
capture_output=True, text=True, timeout=limite)
|
||||||
|
|
||||||
|
|
||||||
|
def genera(texto, voz, velocidad, ruido, destino):
|
||||||
|
crudo = tempfile.mktemp(suffix=".wav")
|
||||||
|
try:
|
||||||
|
r = subprocess.run(
|
||||||
|
[PIPER, "--model", os.path.join(MODELOS_VOZ, voz + ".onnx"),
|
||||||
|
"--length_scale", str(1 / velocidad), "--output_file", crudo],
|
||||||
|
input=texto, capture_output=True, text=True, timeout=60)
|
||||||
|
if r.returncode != 0 or not os.path.exists(crudo):
|
||||||
|
return False
|
||||||
|
filtros = "aresample=16000" + ("," + ruido if ruido else "")
|
||||||
|
subprocess.run(["ffmpeg", "-hide_banner", "-loglevel", "error",
|
||||||
|
"-i", crudo, "-ac", "1", "-af", filtros, "-y", destino],
|
||||||
|
check=True, timeout=60)
|
||||||
|
return os.path.exists(destino)
|
||||||
|
except (OSError, subprocess.SubprocessError):
|
||||||
|
return False
|
||||||
|
finally:
|
||||||
|
if os.path.exists(crudo):
|
||||||
|
os.remove(crudo)
|
||||||
|
|
||||||
|
|
||||||
|
def transcribe(carpeta, ficheros, hilos=8, por_tanda=40):
|
||||||
|
salida = {}
|
||||||
|
for i in range(0, len(ficheros), por_tanda):
|
||||||
|
tanda = ficheros[i:i + por_tanda]
|
||||||
|
lista = " ".join(f'"{carpeta}/{n}"' for n in tanda)
|
||||||
|
orden = (f'for f in {lista}; do echo "### $(basename "$f")"; '
|
||||||
|
f'{WHISPER} -m {MODELOS_STT}/ggml-base.bin -l es -nt -t {hilos} '
|
||||||
|
f'-f "$f" 2>/dev/null | tr "\\n" " "; echo; done')
|
||||||
|
try:
|
||||||
|
r = dentro(orden)
|
||||||
|
except subprocess.SubprocessError:
|
||||||
|
continue
|
||||||
|
actual = None
|
||||||
|
for linea in r.stdout.splitlines():
|
||||||
|
if linea.startswith("### "):
|
||||||
|
actual = linea[4:].strip()
|
||||||
|
elif actual:
|
||||||
|
salida[actual] = linea.strip()
|
||||||
|
actual = None
|
||||||
|
return salida
|
||||||
|
|
||||||
|
|
||||||
|
def catalogo_base():
|
||||||
|
ruta = CATALOGO if os.path.exists(CATALOGO) else CATALOGO_FUENTE
|
||||||
|
with open(ruta) as f:
|
||||||
|
return json.load(f)["acciones"], ruta
|
||||||
|
|
||||||
|
|
||||||
|
def evalua(motor, textos, indice):
|
||||||
|
"""(aciertos, total, candidatos{id: {frase_mal: veces}})."""
|
||||||
|
aciertos = 0
|
||||||
|
candidatos = defaultdict(lambda: defaultdict(int))
|
||||||
|
for nombre, (ident, frase) in indice.items():
|
||||||
|
oido = textos.get(nombre, "").strip()
|
||||||
|
if not oido:
|
||||||
|
continue
|
||||||
|
a, _ = _CAT.busca(oido)
|
||||||
|
if a is not None and a.id == ident:
|
||||||
|
aciertos += 1
|
||||||
|
else:
|
||||||
|
candidatos[ident][motor.normaliza(oido)] += 1
|
||||||
|
return aciertos, len([1 for n in indice if textos.get(n)]), candidatos
|
||||||
|
|
||||||
|
|
||||||
|
_CAT = None
|
||||||
|
|
||||||
|
|
||||||
|
# Palabras de funcion: aparecen en cualquier frase y no distinguen una orden de
|
||||||
|
# una conversacion. Un alias hecho solo de estas ("que me tengo") es una trampa.
|
||||||
|
VACIAS = {
|
||||||
|
"que", "de", "la", "el", "los", "las", "un", "una", "me", "te", "se", "lo",
|
||||||
|
"mi", "tu", "su", "es", "esta", "estan", "hay", "por", "para", "con", "en",
|
||||||
|
"y", "o", "a", "al", "del", "como", "cuanto", "cuanta", "muy", "ya", "he",
|
||||||
|
"ha", "tengo", "tiene", "esto", "eso", "aqui", "ahi", "va", "van", "asi",
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
def contenido(frase: str) -> set:
|
||||||
|
"""Las palabras con significado: las que de verdad identifican la orden."""
|
||||||
|
return {p for p in frase.split() if len(p) > 3 and p not in VACIAS}
|
||||||
|
|
||||||
|
|
||||||
|
def filtra_candidatos(motor, candidatos, acciones):
|
||||||
|
"""Solo los alias que valen: sistematicos, sin ambiguedad, y que conservan
|
||||||
|
una palabra distintiva de la orden original.
|
||||||
|
|
||||||
|
El guardarrail clave es el ultimo: una confusion del reconocedor que aun
|
||||||
|
sirve de alias mantiene al menos una palabra con significado ("kernel",
|
||||||
|
"wikipedia", "bateria"). Si las perdio todas y solo quedan palabras de
|
||||||
|
relleno, es indistinguible de una frase de charla y se descarta, por mucho
|
||||||
|
que se haya repetido. Es lo que separa "que kernel tengo" -> "que kernel me
|
||||||
|
tengo" (vale) de "que me tengo" (no vale).
|
||||||
|
"""
|
||||||
|
porfrase = defaultdict(set)
|
||||||
|
for ident, frases in candidatos.items():
|
||||||
|
for f in frases:
|
||||||
|
porfrase[f].add(ident)
|
||||||
|
|
||||||
|
porid = {a["id"]: a for a in acciones}
|
||||||
|
|
||||||
|
propuestos = defaultdict(list)
|
||||||
|
for ident, frases in candidatos.items():
|
||||||
|
accion = porid.get(ident)
|
||||||
|
if accion is None:
|
||||||
|
continue
|
||||||
|
# Las de argumento no generan alias: el relleno de prueba ("notas") se
|
||||||
|
# cuela en la transcripcion y quedaria horneado en el alias. Su
|
||||||
|
# emparejamiento ya es por parecido del arranque, que las cubre.
|
||||||
|
if accion.get("captura"):
|
||||||
|
continue
|
||||||
|
|
||||||
|
orig = motor.normaliza(accion["frases"][0] if accion["frases"] else "")
|
||||||
|
claves = contenido(orig)
|
||||||
|
|
||||||
|
for f, veces in frases.items():
|
||||||
|
if veces < UMBRAL_SISTEMATICO:
|
||||||
|
continue
|
||||||
|
if len(porfrase[f]) > 1: # la misma frase, dos acciones
|
||||||
|
continue
|
||||||
|
if len(f.split()) < 2: # una palabra engancha de todo
|
||||||
|
continue
|
||||||
|
if _CAT.busca(f)[0] is not None: # ya lo coge algo
|
||||||
|
continue
|
||||||
|
if motor.parecido(f, orig) < 0.6: # se perdio del todo: ruido
|
||||||
|
continue
|
||||||
|
# conserva una palabra distintiva? exacta o casi (el reconocedor
|
||||||
|
# cambia una letra: "wikipedia" -> "wikipeda")
|
||||||
|
palabras_f = set(f.split())
|
||||||
|
if claves and not any(
|
||||||
|
c in palabras_f or any(motor.parecido(c, w) > 0.8 for w in palabras_f)
|
||||||
|
for c in claves):
|
||||||
|
continue
|
||||||
|
propuestos[ident].append((f, veces))
|
||||||
|
return propuestos
|
||||||
|
|
||||||
|
|
||||||
|
def aplica(propuestos, acciones_orig):
|
||||||
|
"""Escribe los alias en el catalogo propio. Devuelve cuantos."""
|
||||||
|
try:
|
||||||
|
with open(PROPIO) as f:
|
||||||
|
propio = json.load(f)
|
||||||
|
except (OSError, json.JSONDecodeError):
|
||||||
|
propio = {"version": 1, "acciones": []}
|
||||||
|
porid = {a["id"]: a for a in propio.get("acciones", [])}
|
||||||
|
original = {a["id"]: a for a in acciones_orig}
|
||||||
|
|
||||||
|
n = 0
|
||||||
|
for ident, lista in propuestos.items():
|
||||||
|
entrada = porid.get(ident)
|
||||||
|
if entrada is None:
|
||||||
|
entrada = dict(original[ident])
|
||||||
|
porid[ident] = entrada
|
||||||
|
propio.setdefault("acciones", []).append(entrada)
|
||||||
|
if len(entrada["frases"]) >= TOPE_ALIAS_POR_ACCION:
|
||||||
|
continue
|
||||||
|
for f, _ in lista:
|
||||||
|
if f not in entrada["frases"]:
|
||||||
|
entrada["frases"].append(f)
|
||||||
|
n += 1
|
||||||
|
with open(PROPIO, "w") as f:
|
||||||
|
json.dump(propio, f, indent=2, ensure_ascii=False)
|
||||||
|
return n
|
||||||
|
|
||||||
|
|
||||||
|
def charla_se_cuela(motor):
|
||||||
|
"""True si alguna frase de charla acaba en una accion. El guardarrail."""
|
||||||
|
for frase in CHARLA:
|
||||||
|
a, _ = _CAT.busca(frase)
|
||||||
|
if a is not None:
|
||||||
|
return frase, a.id
|
||||||
|
return None
|
||||||
|
|
||||||
|
|
||||||
|
def marcador_guarda(datos):
|
||||||
|
try:
|
||||||
|
with open(MARCADOR, "w") as f:
|
||||||
|
json.dump(datos, f, indent=2, ensure_ascii=False)
|
||||||
|
except OSError:
|
||||||
|
pass
|
||||||
|
|
||||||
|
|
||||||
|
def copia_catalogo(ronda):
|
||||||
|
if not os.path.exists(PROPIO):
|
||||||
|
return
|
||||||
|
os.makedirs(COPIAS, exist_ok=True)
|
||||||
|
shutil.copy2(PROPIO, os.path.join(COPIAS, f"ronda_{ronda:03d}.json"))
|
||||||
|
|
||||||
|
|
||||||
|
def una_ronda(motor, ronda, muestras_por_acap):
|
||||||
|
global _CAT
|
||||||
|
acciones, _ = catalogo_base()
|
||||||
|
|
||||||
|
# muestras de esta ronda: condiciones aleatorias, distintas cada vez
|
||||||
|
trabajos = []
|
||||||
|
for a in acciones:
|
||||||
|
if not a["frases"]:
|
||||||
|
continue
|
||||||
|
frase = a["frases"][0]
|
||||||
|
if a.get("captura"):
|
||||||
|
frase += " " + random.choice(RELLENOS)
|
||||||
|
for _ in range(muestras_por_acap):
|
||||||
|
trabajos.append((a["id"], frase, random.choice(VOCES),
|
||||||
|
random.choice(VELOCIDADES), random.choice(RUIDOS)))
|
||||||
|
random.shuffle(trabajos)
|
||||||
|
|
||||||
|
shutil.rmtree(WAVS, ignore_errors=True)
|
||||||
|
os.makedirs(WAVS, exist_ok=True)
|
||||||
|
indice = {}
|
||||||
|
for n, (ident, frase, voz, vel, ruido) in enumerate(trabajos, 1):
|
||||||
|
nombre = f"{n:05d}.wav"
|
||||||
|
if genera(frase, voz, vel, ruido, os.path.join(WAVS, nombre)):
|
||||||
|
indice[nombre] = (ident, frase)
|
||||||
|
|
||||||
|
log(f"ronda {ronda}: {len(indice)} frases dichas, transcribiendo...")
|
||||||
|
textos = transcribe(WAVS, sorted(indice))
|
||||||
|
|
||||||
|
# medir ANTES de tocar nada
|
||||||
|
_CAT = motor.Catalogo([p for p in (PROPIO, CATALOGO) if os.path.exists(p)]
|
||||||
|
or [CATALOGO_FUENTE])
|
||||||
|
aciertos, total, candidatos = evalua(motor, textos, indice)
|
||||||
|
antes = 100 * aciertos / max(1, total)
|
||||||
|
log(f"ronda {ronda}: acierto {antes:.1f} % ({aciertos}/{total})")
|
||||||
|
|
||||||
|
propuestos = filtra_candidatos(motor, candidatos, acciones)
|
||||||
|
nuevos = sum(len(v) for v in propuestos.values())
|
||||||
|
if not nuevos:
|
||||||
|
log(f"ronda {ronda}: sin alias nuevos que valgan")
|
||||||
|
return antes, 0, False
|
||||||
|
|
||||||
|
# aplicar en el catalogo propio, con copia de seguridad antes
|
||||||
|
copia_catalogo(ronda)
|
||||||
|
n = aplica(propuestos, acciones)
|
||||||
|
|
||||||
|
# revalidar: recargar el catalogo con los alias puestos
|
||||||
|
_CAT = motor.Catalogo([p for p in (PROPIO, CATALOGO) if os.path.exists(p)]
|
||||||
|
or [CATALOGO_FUENTE])
|
||||||
|
|
||||||
|
# GUARDARRAIL 1: la charla no se cuela
|
||||||
|
cuela = charla_se_cuela(motor)
|
||||||
|
if cuela:
|
||||||
|
frase, ident = cuela
|
||||||
|
log(f"ronda {ronda}: REVERTIDA — '{frase}' se colaria en {ident}")
|
||||||
|
shutil.copy2(os.path.join(COPIAS, f"ronda_{ronda:03d}.json"), PROPIO)
|
||||||
|
return antes, 0, False
|
||||||
|
|
||||||
|
# GUARDARRAIL 2: el acierto sube en las mismas muestras
|
||||||
|
aciertos2, _, _ = evalua(motor, textos, indice)
|
||||||
|
despues = 100 * aciertos2 / max(1, total)
|
||||||
|
if despues < antes - 0.5:
|
||||||
|
log(f"ronda {ronda}: REVERTIDA — el acierto bajaria a {despues:.1f} %")
|
||||||
|
shutil.copy2(os.path.join(COPIAS, f"ronda_{ronda:03d}.json"), PROPIO)
|
||||||
|
return antes, 0, False
|
||||||
|
|
||||||
|
log(f"ronda {ronda}: +{n} alias · acierto {antes:.1f} -> {despues:.1f} %")
|
||||||
|
for ident, lista in sorted(propuestos.items()):
|
||||||
|
for f, v in lista[:2]:
|
||||||
|
log(f" {ident} <- \"{f}\" ({v}x)")
|
||||||
|
return despues, n, True
|
||||||
|
|
||||||
|
|
||||||
|
def main():
|
||||||
|
ap = argparse.ArgumentParser()
|
||||||
|
ap.add_argument("--horas", type=float, default=0, help="parar tras N horas")
|
||||||
|
ap.add_argument("--ronda", action="store_true", help="una sola ronda")
|
||||||
|
ap.add_argument("--muestras", type=int, default=3,
|
||||||
|
help="muestras por accion y ronda")
|
||||||
|
ap.add_argument("--dry", type=int, default=DRY_PARA_PARAR,
|
||||||
|
help="rondas secas seguidas antes de parar")
|
||||||
|
args = ap.parse_args()
|
||||||
|
|
||||||
|
for ruta, que in ((PIPER, "piper"), (WHISPER, "whisper")):
|
||||||
|
if not os.path.exists(ruta):
|
||||||
|
print(f"falta {que}: {ruta}")
|
||||||
|
return 1
|
||||||
|
|
||||||
|
os.makedirs(SALA, exist_ok=True)
|
||||||
|
limite = time.time() + args.horas * 3600 if args.horas else None
|
||||||
|
motor = carga_motor()
|
||||||
|
|
||||||
|
log("=" * 56)
|
||||||
|
log(f"arranca la mejora nocturna · {args.muestras} muestras/accion/ronda")
|
||||||
|
if limite:
|
||||||
|
log(f"parara en {args.horas} h")
|
||||||
|
else:
|
||||||
|
log("corre hasta converger o hasta que la pares")
|
||||||
|
|
||||||
|
historial = []
|
||||||
|
dry = 0
|
||||||
|
ronda = 0
|
||||||
|
try:
|
||||||
|
while True:
|
||||||
|
ronda += 1
|
||||||
|
libre = disco_libre_gb()
|
||||||
|
if libre < 10:
|
||||||
|
log(f'PARADA: solo quedan {libre:.1f} GB de disco. Fin por seguridad.')
|
||||||
|
break
|
||||||
|
ini = time.time()
|
||||||
|
try:
|
||||||
|
score, nuevos, aplicado = una_ronda(motor, ronda, args.muestras)
|
||||||
|
except Exception as e:
|
||||||
|
log(f"ronda {ronda}: error, se salta — {type(e).__name__}: {e}")
|
||||||
|
time.sleep(5)
|
||||||
|
continue
|
||||||
|
|
||||||
|
historial.append({"ronda": ronda, "acierto": round(score, 1),
|
||||||
|
"alias_nuevos": nuevos,
|
||||||
|
"minutos": round((time.time() - ini) / 60, 1)})
|
||||||
|
marcador_guarda({
|
||||||
|
"actualizado": time.strftime("%Y-%m-%d %H:%M"),
|
||||||
|
"rondas": ronda, "ultimo_acierto": round(score, 1),
|
||||||
|
"alias_totales": alias_totales(),
|
||||||
|
"historial": historial[-40:],
|
||||||
|
})
|
||||||
|
|
||||||
|
dry = dry + 1 if nuevos == 0 else 0
|
||||||
|
if args.ronda:
|
||||||
|
break
|
||||||
|
if dry >= args.dry:
|
||||||
|
log(f"converge: {DRY_PARA_PARAR} rondas sin nada nuevo. Fin.")
|
||||||
|
break
|
||||||
|
if limite and time.time() > limite:
|
||||||
|
log("se acabo el tiempo pedido. Fin.")
|
||||||
|
break
|
||||||
|
except KeyboardInterrupt:
|
||||||
|
log("parada a mano")
|
||||||
|
|
||||||
|
shutil.rmtree(WAVS, ignore_errors=True)
|
||||||
|
log(f"terminado tras {ronda} rondas · acierto final "
|
||||||
|
f"{historial[-1]['acierto'] if historial else '?'} % · "
|
||||||
|
f"{alias_totales()} alias en el catalogo propio")
|
||||||
|
log("los cambios estan en jarvis-acciones.json; se aplican al abrir JARVIS")
|
||||||
|
return 0
|
||||||
|
|
||||||
|
|
||||||
|
def alias_totales():
|
||||||
|
try:
|
||||||
|
with open(PROPIO) as f:
|
||||||
|
d = json.load(f)
|
||||||
|
base = {a["id"]: len(a["frases"]) for a in
|
||||||
|
json.load(open(CATALOGO if os.path.exists(CATALOGO)
|
||||||
|
else CATALOGO_FUENTE))["acciones"]}
|
||||||
|
return sum(max(0, len(a["frases"]) - base.get(a["id"], 0))
|
||||||
|
for a in d.get("acciones", []))
|
||||||
|
except (OSError, json.JSONDecodeError):
|
||||||
|
return 0
|
||||||
|
|
||||||
|
|
||||||
|
if __name__ == "__main__":
|
||||||
|
sys.exit(main())
|
||||||
66
config/muestra_voz.py
Normal file
66
config/muestra_voz.py
Normal file
|
|
@ -0,0 +1,66 @@
|
||||||
|
#!/usr/bin/env python3
|
||||||
|
"""Genera muestras de la voz JARVIS: seca y con tratamiento.
|
||||||
|
|
||||||
|
Se ejecuta DENTRO del flatpak, que es donde viven Kokoro y ffmpeg:
|
||||||
|
|
||||||
|
flatpak run --command=python3 io.github.qwersyk.Newelle//master \
|
||||||
|
~/COFRE/CODERS/JARVIS/config/muestra_voz.py
|
||||||
|
|
||||||
|
Sirve para juzgar la voz de oido antes de montar una conversacion entera,
|
||||||
|
y para comparar el efecto del filtro (que es la mitad del caracter JARVIS).
|
||||||
|
Deja los wav en ~/COFRE/CODERS/JARVIS/muestras/.
|
||||||
|
"""
|
||||||
|
import os
|
||||||
|
import subprocess
|
||||||
|
import sys
|
||||||
|
|
||||||
|
sys.path.insert(0, "/app/share/newelle")
|
||||||
|
# Los modulos que Newelle instala bajo demanda (kokoro-onnx, soundfile...) no
|
||||||
|
# van al site-packages del sistema sino a config/pip, que la app añade al
|
||||||
|
# sys.path al arrancar. Un script suelto tiene que hacerlo a mano.
|
||||||
|
sys.path.insert(0, os.path.expanduser(
|
||||||
|
"~/.var/app/io.github.qwersyk.Newelle/config/pip"))
|
||||||
|
|
||||||
|
from gi.repository import Gio # noqa: E402
|
||||||
|
|
||||||
|
from newelle.handlers.tts.kokoro_handler import KokoroTTSHandler # noqa: E402
|
||||||
|
from newelle.handlers.tts.tts import jarvis_audio_filter # noqa: E402
|
||||||
|
|
||||||
|
FRASE = ("Good evening, sir. All systems are running locally. "
|
||||||
|
"You have 846 gigabytes free and the GPU is idle.")
|
||||||
|
|
||||||
|
SALIDA = os.path.expanduser("~/COFRE/CODERS/JARVIS/muestras")
|
||||||
|
CONFIG = os.path.expanduser("~/.var/app/io.github.qwersyk.Newelle/config")
|
||||||
|
|
||||||
|
|
||||||
|
def main():
|
||||||
|
os.makedirs(SALIDA, exist_ok=True)
|
||||||
|
settings = Gio.Settings.new("io.github.qwersyk.Newelle")
|
||||||
|
handler = KokoroTTSHandler(settings, os.path.join(CONFIG, "models"))
|
||||||
|
|
||||||
|
if not handler.is_installed():
|
||||||
|
print("Kokoro no instalado, instalando (pip + modelos, tarda)...")
|
||||||
|
handler.install()
|
||||||
|
print("instalado")
|
||||||
|
|
||||||
|
voz = handler.get_current_voice()
|
||||||
|
print(f"voz: {voz}")
|
||||||
|
|
||||||
|
seca = os.path.join(SALIDA, "jarvis_seca.wav")
|
||||||
|
handler.save_audio(FRASE, seca)
|
||||||
|
print(f"seca: {seca} ({os.path.getsize(seca)} bytes)")
|
||||||
|
|
||||||
|
filtro = jarvis_audio_filter()
|
||||||
|
tratada = os.path.join(SALIDA, "jarvis_tratada.wav")
|
||||||
|
subprocess.run(
|
||||||
|
["ffmpeg", "-hide_banner", "-loglevel", "error",
|
||||||
|
"-i", seca, "-af", filtro, "-y", tratada],
|
||||||
|
check=True,
|
||||||
|
)
|
||||||
|
print(f"tratada: {tratada} ({os.path.getsize(tratada)} bytes)")
|
||||||
|
print(f"filtro: {filtro}")
|
||||||
|
return 0
|
||||||
|
|
||||||
|
|
||||||
|
if __name__ == "__main__":
|
||||||
|
sys.exit(main())
|
||||||
207
config/noche.sh
Executable file
207
config/noche.sh
Executable file
|
|
@ -0,0 +1,207 @@
|
||||||
|
#!/usr/bin/env bash
|
||||||
|
# Pipeline nocturno: JARVIS se mejora solo mientras nadie mira.
|
||||||
|
#
|
||||||
|
# Cada ciclo hace lo mismo: mira los datos que ha dejado el uso real, propone
|
||||||
|
# un cambio, lo aplica, y lo somete a config/puerta.sh. Si la puerta dice que
|
||||||
|
# no, se revierte ENTERO con git y se pasa al siguiente. Nada se queda sin
|
||||||
|
# pasar por ahi.
|
||||||
|
#
|
||||||
|
# Por que git y no una copia: el arbol ya esta versionado, `git checkout` es
|
||||||
|
# atomico y deja rastro de lo que se intento. Al terminar la noche se puede ver
|
||||||
|
# commit a commit que se cambio y por que.
|
||||||
|
#
|
||||||
|
# noche.sh corre hasta que se le diga que pare
|
||||||
|
# noche.sh --ciclos 5 solo cinco vueltas
|
||||||
|
# noche.sh --seco propone y valida, pero NO commitea (para mirar)
|
||||||
|
#
|
||||||
|
# Para pararlo: touch ~/COFRE/CODERS/JARVIS/PARAR
|
||||||
|
#
|
||||||
|
# ── Que puede mejorar solo, y que no ────────────────────────────────────────
|
||||||
|
#
|
||||||
|
# Se mejora solo lo que se puede VALIDAR solo. Eso es:
|
||||||
|
# · el vocabulario: alias nuevos para ordenes que no se entendieron
|
||||||
|
# · las frases del catalogo: variantes de las que fallan
|
||||||
|
# · la voz: regenerar en la voz buena las frases que cayeron a la de reserva
|
||||||
|
# · el prompt: mantenerlo al dia con el catalogo
|
||||||
|
# · acciones nuevas a partir de lo que se pidio y no existia
|
||||||
|
#
|
||||||
|
# NO se toca solo el motor, el panel ni la logica de la aplicacion. No porque
|
||||||
|
# sea imposible generarlo, sino porque no hay forma automatica de comprobar que
|
||||||
|
# un cambio ahi es bueno: la suite dice si algo se rompio, no si algo mejoro.
|
||||||
|
# Un bucle que reescribe su propio validador acaba pasando siempre.
|
||||||
|
set -uo pipefail
|
||||||
|
|
||||||
|
# ── DESACTIVADO EL 15 DE AGOSTO DE 2026 ────────────────────────────────────
|
||||||
|
#
|
||||||
|
# Este bucle modifica el arbol de `newelle/` y COMMITEA solo. Ese arbol esta
|
||||||
|
# congelado en la etiqueta jarvis-newelle-final desde que el desarrollo se
|
||||||
|
# mudo a nucleo/: dejarlo correr escribiria commits automaticos sobre un
|
||||||
|
# repositorio que por definicion ya no cambia.
|
||||||
|
#
|
||||||
|
# Se ha quitado tambien su temporizador de systemd —estaba armado para las
|
||||||
|
# 03:30 y habria saltado solo—, movido a ~/.config/systemd/user/desactivados/.
|
||||||
|
#
|
||||||
|
# Esto de aqui es la segunda cerradura: aunque alguien lo lance a mano, se
|
||||||
|
# niega. Para retomarlo hay que apuntarlo primero al nucleo, y eso no es
|
||||||
|
# cambiar una ruta: la puerta (config/puerta.sh) valida el catalogo, el
|
||||||
|
# generador y la suite VIEJOS, y el nucleo tiene los suyos.
|
||||||
|
if [ "${JARVIS_NOCHE_A_SABIENDAS:-}" != "si" ]; then
|
||||||
|
cat >&2 <<'AVISO'
|
||||||
|
noche.sh esta desactivado.
|
||||||
|
|
||||||
|
Modifica y commitea sobre newelle/, que esta congelado en jarvis-newelle-final
|
||||||
|
desde que el desarrollo se mudo a nucleo/. Su temporizador de systemd tambien
|
||||||
|
se retiro.
|
||||||
|
|
||||||
|
Para retomarlo hay que reescribirlo contra el nucleo: la puerta valida el
|
||||||
|
catalogo, el generador y la suite viejos.
|
||||||
|
|
||||||
|
Si de verdad quieres correrlo tal cual sobre el arbol congelado:
|
||||||
|
JARVIS_NOCHE_A_SABIENDAS=si config/noche.sh
|
||||||
|
AVISO
|
||||||
|
exit 78
|
||||||
|
fi
|
||||||
|
|
||||||
|
RAIZ=$(cd -P "$(dirname "${BASH_SOURCE[0]:-$0}")/.." && pwd)
|
||||||
|
cd "$RAIZ"
|
||||||
|
PARADA=$RAIZ/PARAR
|
||||||
|
DIARIO=$RAIZ/noche.log
|
||||||
|
CICLOS=0; SECO=no
|
||||||
|
while [ $# -gt 0 ]; do
|
||||||
|
case "$1" in
|
||||||
|
--ciclos) CICLOS=${2:-0}; shift 2;;
|
||||||
|
--seco) SECO=si; shift;;
|
||||||
|
*) shift;;
|
||||||
|
esac
|
||||||
|
done
|
||||||
|
|
||||||
|
log() { printf '%s %s\n' "$(date +%H:%M:%S)" "$*" | tee -a "$DIARIO"; }
|
||||||
|
|
||||||
|
# ── salvaguarda ────────────────────────────────────────────────────────────
|
||||||
|
cd "$RAIZ/newelle"
|
||||||
|
if [ -n "$(git status --porcelain)" ]; then
|
||||||
|
log "ABORTO: el fork tiene cambios sin commitear. Commitealos o descartalos."
|
||||||
|
exit 1
|
||||||
|
fi
|
||||||
|
ANCLA=$(git rev-parse HEAD)
|
||||||
|
git tag -f "noche-$(date +%Y%m%d-%H%M)" >/dev/null 2>&1
|
||||||
|
log "ancla: $ANCLA (para volver: git reset --hard $ANCLA)"
|
||||||
|
cd "$RAIZ"
|
||||||
|
|
||||||
|
# ── las mejoras, cada una en su funcion ────────────────────────────────────
|
||||||
|
# Cada una devuelve 0 si propuso algo, 1 si no habia nada que hacer.
|
||||||
|
|
||||||
|
mejora_vocabulario() {
|
||||||
|
# Lo que el usuario dijo y no se entendio. Es la fuente mas valiosa porque
|
||||||
|
# son fallos REALES, no inventados.
|
||||||
|
local registro=$HOME/.var/app/io.github.qwersyk.Newelle/config/jarvis-sin-accion.jsonl
|
||||||
|
[ -f "$registro" ] || return 1
|
||||||
|
python3 "$RAIZ/config/proponer_alias.py" --aplicar 2>&1 | tail -3
|
||||||
|
return ${PIPESTATUS[0]}
|
||||||
|
}
|
||||||
|
|
||||||
|
mejora_frases() {
|
||||||
|
# Variantes de las frases del catalogo, generadas con el modelo local y
|
||||||
|
# filtradas duro. Sube la cobertura sin tocar comandos.
|
||||||
|
python3 "$RAIZ/config/proponer_frases.py" --aplicar 2>&1 | tail -3
|
||||||
|
return ${PIPESTATUS[0]}
|
||||||
|
}
|
||||||
|
|
||||||
|
mejora_voz() {
|
||||||
|
# Las frases que cayeron a la voz de reserva se regeneran con la clonada.
|
||||||
|
[ -s "$RAIZ/voz/misses.log" ] || return 1
|
||||||
|
"$RAIZ/voz/clonador-venv/bin/python" "$RAIZ/voz/calienta_cache.py" cpu 2>&1 | tail -2
|
||||||
|
return 0
|
||||||
|
}
|
||||||
|
|
||||||
|
mejora_prompt() {
|
||||||
|
# El prompt lleva la lista de capacidades: si cambio el catalogo, hay que
|
||||||
|
# regenerarlo o el modelo sigue creyendo que sabe hacer otra cosa.
|
||||||
|
flatpak run --command=python3 io.github.qwersyk.Newelle//master \
|
||||||
|
"$RAIZ/config/set_persona.py" 2>&1 | grep -v WARNING | tail -1
|
||||||
|
return 0
|
||||||
|
}
|
||||||
|
|
||||||
|
mejora_reconocimiento() {
|
||||||
|
# La unica que genera sus PROPIOS datos: dice las frases del catalogo con
|
||||||
|
# varias voces, velocidades y ruidos, las transcribe con el mismo Whisper
|
||||||
|
# del asistente, y propone alias para lo que no llega a su accion.
|
||||||
|
#
|
||||||
|
# Es la que hace productiva la noche aunque nadie hable con JARVIS. Ya trae
|
||||||
|
# su propio guardarrail —solo aplica si el acierto sube Y la charla sigue
|
||||||
|
# yendo al modelo— y ademas pasa por la puerta como todo lo demas.
|
||||||
|
timeout 3000 python3 "$RAIZ/config/mejora_nocturna.py" --ronda --muestras 2 2>&1 | tail -4
|
||||||
|
return ${PIPESTATUS[0]}
|
||||||
|
}
|
||||||
|
|
||||||
|
MEJORAS=(mejora_reconocimiento mejora_vocabulario mejora_frases mejora_prompt mejora_voz)
|
||||||
|
|
||||||
|
# ── el bucle ───────────────────────────────────────────────────────────────
|
||||||
|
vuelta=0
|
||||||
|
aceptados=0; rechazados=0; sin_nada=0
|
||||||
|
log "=== empieza la noche ==="
|
||||||
|
|
||||||
|
while true; do
|
||||||
|
[ -f "$PARADA" ] && { log "parada pedida (existe $PARADA)"; break; }
|
||||||
|
[ "$CICLOS" -gt 0 ] && [ "$vuelta" -ge "$CICLOS" ] && { log "hechas $CICLOS vueltas"; break; }
|
||||||
|
vuelta=$((vuelta+1))
|
||||||
|
|
||||||
|
for mejora in "${MEJORAS[@]}"; do
|
||||||
|
[ -f "$PARADA" ] && break
|
||||||
|
log "── vuelta $vuelta · $mejora"
|
||||||
|
|
||||||
|
salida=$($mejora 2>&1); resultado=$?
|
||||||
|
[ -n "$salida" ] && echo "$salida" | sed 's/^/ /' | tee -a "$DIARIO" >/dev/null
|
||||||
|
|
||||||
|
cd "$RAIZ/newelle"
|
||||||
|
cambios=$(git status --porcelain)
|
||||||
|
cd "$RAIZ"
|
||||||
|
if [ -z "$cambios" ] && [ "$resultado" -ne 0 ]; then
|
||||||
|
log " nada que proponer"
|
||||||
|
sin_nada=$((sin_nada+1))
|
||||||
|
continue
|
||||||
|
fi
|
||||||
|
|
||||||
|
if [ -z "$cambios" ]; then
|
||||||
|
log " aplicado fuera del fork (voz o ajustes), sin commit"
|
||||||
|
aceptados=$((aceptados+1))
|
||||||
|
continue
|
||||||
|
fi
|
||||||
|
|
||||||
|
# ── LA PUERTA ──
|
||||||
|
if timeout 2400 "$RAIZ/config/puerta.sh" completa > "$RAIZ/.puerta.txt" 2>&1; then
|
||||||
|
if [ "$SECO" = si ]; then
|
||||||
|
log " [seco] habria pasado la puerta; se revierte igual"
|
||||||
|
(cd "$RAIZ/newelle" && git checkout -- . && git clean -fd >/dev/null 2>&1)
|
||||||
|
else
|
||||||
|
(cd "$RAIZ/newelle" && git add -A && \
|
||||||
|
git commit -q -m "auto($mejora): mejora nocturna
|
||||||
|
|
||||||
|
Propuesto y validado por config/noche.sh sin intervencion. Paso la
|
||||||
|
puerta completa: catalogo valido, generador reproducible, emparejador
|
||||||
|
sin perdidas, 150 acciones respondiendo y la suite en verde.
|
||||||
|
|
||||||
|
$(echo "$salida" | head -3)")
|
||||||
|
log " ACEPTADO y commiteado"
|
||||||
|
aceptados=$((aceptados+1))
|
||||||
|
fi
|
||||||
|
else
|
||||||
|
log " RECHAZADO: $(tail -1 "$RAIZ/.puerta.txt")"
|
||||||
|
(cd "$RAIZ/newelle" && git checkout -- . && git clean -fd >/dev/null 2>&1)
|
||||||
|
rechazados=$((rechazados+1))
|
||||||
|
fi
|
||||||
|
done
|
||||||
|
|
||||||
|
# Si una vuelta entera no propuso nada, no tiene sentido seguir dando
|
||||||
|
# vueltas en vacio: se espera a que el uso genere datos nuevos.
|
||||||
|
if [ "$sin_nada" -ge $(( ${#MEJORAS[@]} )) ]; then
|
||||||
|
log "una vuelta entera sin nada que hacer; esperando 30 min"
|
||||||
|
for _ in $(seq 180); do [ -f "$PARADA" ] && break; sleep 10; done
|
||||||
|
sin_nada=0
|
||||||
|
fi
|
||||||
|
done
|
||||||
|
|
||||||
|
log "=== fin: $aceptados aceptados, $rechazados rechazados, $vuelta vueltas ==="
|
||||||
|
cd "$RAIZ/newelle"
|
||||||
|
log "commits de esta noche:"
|
||||||
|
git log --oneline "$ANCLA"..HEAD 2>/dev/null | sed 's/^/ /' | tee -a "$DIARIO"
|
||||||
49
config/permisos_maquina.sh
Executable file
49
config/permisos_maquina.sh
Executable file
|
|
@ -0,0 +1,49 @@
|
||||||
|
#!/usr/bin/env bash
|
||||||
|
# Sacar a JARVIS de la burbuja: que lo que ejecute sea en la maquina de verdad.
|
||||||
|
#
|
||||||
|
# El sintoma era que el asistente contestaba que "esta en un contenedor" y no
|
||||||
|
# podia hacer casi nada. Las 134 acciones del catalogo ya salian al host (todas
|
||||||
|
# llevan host:true), pero los comandos LIBRES —los que se inventa el modelo
|
||||||
|
# cuando lo que pides no esta en el catalogo— corrian dentro del sandbox, donde
|
||||||
|
# no hay ni tu Debian ni tus discos:
|
||||||
|
#
|
||||||
|
# dentro: PRETTY_NAME="GNOME 50 (Flatpak runtime)" sin /media, sin systemctl
|
||||||
|
# fuera: PRETTY_NAME="Debian GNU/Linux 12" /media, systemctl, docker
|
||||||
|
#
|
||||||
|
# Son dos capas distintas y hacen falta las dos:
|
||||||
|
#
|
||||||
|
# 1. `virtualization` (ajuste de Newelle). Decide si los comandos del modelo
|
||||||
|
# llevan delante `flatpak-spawn --host`. Estaba en true = todo dentro.
|
||||||
|
# Es lo que mira _host_prefix() en integrations/default_tools.py.
|
||||||
|
#
|
||||||
|
# 2. Los permisos del flatpak. Aunque los comandos salgan al host, las
|
||||||
|
# herramientas de FICHEROS de la app (leer, editar, indexar) son Python
|
||||||
|
# corriendo dentro: solo ven lo que el sandbox les deje. Estaba en
|
||||||
|
# `filesystems=home`, asi que fuera de tu carpeta personal no veia nada.
|
||||||
|
#
|
||||||
|
# Lo que esto NO quita: el candado de la contraseña al abrir, la confirmacion
|
||||||
|
# de lo destructivo, ni el dialogo de root. Esos siguen. Lo que cambia es que
|
||||||
|
# cuando TU autorizas algo, se ejecuta donde tiene que ejecutarse.
|
||||||
|
set -eu
|
||||||
|
|
||||||
|
APPID=io.github.qwersyk.Newelle
|
||||||
|
RAMA=${1:-master}
|
||||||
|
|
||||||
|
echo "1. comandos del modelo -> a la maquina, no a la burbuja"
|
||||||
|
flatpak run --command=gsettings "$APPID//$RAMA" set "$APPID" virtualization false
|
||||||
|
|
||||||
|
echo "2. permisos de ficheros -> todo el disco"
|
||||||
|
# host = el sistema de ficheros (salvo /usr y /etc, que van aparte)
|
||||||
|
# host-etc = /etc, para leer configuracion del sistema
|
||||||
|
# host-os = /usr, para mirar lo instalado
|
||||||
|
flatpak override --user \
|
||||||
|
--filesystem=host \
|
||||||
|
--filesystem=host-etc \
|
||||||
|
--filesystem=host-os \
|
||||||
|
"$APPID"
|
||||||
|
|
||||||
|
echo
|
||||||
|
echo "como queda:"
|
||||||
|
printf ' virtualization = %s\n' \
|
||||||
|
"$(flatpak run --command=gsettings "$APPID//$RAMA" get "$APPID" virtualization)"
|
||||||
|
flatpak info --show-permissions "$APPID//$RAMA" 2>/dev/null | grep -E "^filesystems=" | sed 's/^/ /'
|
||||||
172
config/probar_acciones.py
Executable file
172
config/probar_acciones.py
Executable file
|
|
@ -0,0 +1,172 @@
|
||||||
|
#!/usr/bin/env python3
|
||||||
|
"""Ejecuta las acciones de verdad y mira si funcionan y si se entienden.
|
||||||
|
|
||||||
|
python3 ~/COFRE/CODERS/JARVIS/config/probar_acciones.py
|
||||||
|
python3 ~/COFRE/CODERS/JARVIS/config/probar_acciones.py --romper # solo las malas
|
||||||
|
|
||||||
|
Las 121 acciones se escribieron a mano y casi ninguna se ha ejecutado nunca.
|
||||||
|
Alguna tendra el comando roto, la salida vacia, o una plantilla que apunta a un
|
||||||
|
campo que no existe —y entonces JARVIS diria una frase sin sentido en voz alta.
|
||||||
|
Esto las corre, captura la salida y las clasifica, para saber cuales arreglar.
|
||||||
|
|
||||||
|
Que hace con cada tipo:
|
||||||
|
- Solo lectura (df, free, ps, cat /sys...): las EJECUTA y comprueba la salida.
|
||||||
|
Son la mayoria y las que de verdad importan, porque son las que hay que
|
||||||
|
"interpretar bien".
|
||||||
|
- Con efecto (abre navegador, apaga pantalla, bloquea, sube volumen): NO las
|
||||||
|
ejecuta —tendria efectos de verdad— pero valida que el comando exista.
|
||||||
|
- Destructivas (confirmar=True): NO las ejecuta, solo comprueba el comando.
|
||||||
|
- Con argumento: las ejecuta con un valor de prueba inofensivo.
|
||||||
|
|
||||||
|
Clasificacion de cada accion:
|
||||||
|
OK corrio, dio salida, y la respuesta hablada sale con datos reales
|
||||||
|
VACIA corrio pero sin salida (la herramienta no aplica en esta maquina)
|
||||||
|
ROTA el comando fallo o no existe
|
||||||
|
PLANTILLA la respuesta cayo al volcado crudo: la plantilla pide un campo que
|
||||||
|
la salida no tiene. Es el fallo que hace que JARVIS suene raro.
|
||||||
|
EFECTO no se ejecuta por tener efectos; comando validado
|
||||||
|
"""
|
||||||
|
import argparse
|
||||||
|
import importlib.util
|
||||||
|
import json
|
||||||
|
import os
|
||||||
|
import re
|
||||||
|
import shlex
|
||||||
|
import subprocess
|
||||||
|
import sys
|
||||||
|
|
||||||
|
JARVIS = os.path.expanduser("~/COFRE/CODERS/JARVIS")
|
||||||
|
MOTOR = os.path.join(JARVIS, "newelle/src/utility/acciones.py")
|
||||||
|
CATALOGO = os.path.expanduser(
|
||||||
|
"~/.local/share/flatpak/app/io.github.qwersyk.Newelle/x86_64/master/"
|
||||||
|
"active/files/share/newelle/acciones/acciones.json")
|
||||||
|
CATALOGO_FUENTE = os.path.join(JARVIS, "newelle/data/acciones/acciones.json")
|
||||||
|
INFORME = os.path.join(JARVIS, "muestras/acciones-salud.json")
|
||||||
|
|
||||||
|
# Órdenes que cambian algo del sistema o abren cosas: se validan pero no se
|
||||||
|
# lanzan, que probar un asistente no deberia dejarte el navegador con veinte
|
||||||
|
# pestañas ni la pantalla apagada.
|
||||||
|
EFECTOS = ["firefox", "xdg-open", "loginctl", "xset", "pactl set", "pkill",
|
||||||
|
"brightnessctl", "systemctl start", "systemctl stop", "import -window",
|
||||||
|
"gnome-screenshot", "rm ", "kill", "--private-window", "dpms",
|
||||||
|
"ventanas.sh", "xdotool", "wmctrl", "xrandr --output"]
|
||||||
|
|
||||||
|
# Valores de prueba para las acciones con argumento, inofensivos a proposito.
|
||||||
|
ARGUMENTOS = {
|
||||||
|
"buscar_fichero": "acciones", "buscar_carpeta": "config",
|
||||||
|
"leer_fichero": "README", "abrir_fichero": "no_existe_xyz",
|
||||||
|
"abrir_carpeta": "no_existe_xyz", "tamano_carpeta": "config",
|
||||||
|
"proceso_buscar": "python", "proceso_matar": "proceso_inexistente_xyz",
|
||||||
|
"instalado": "bash", "manual": "ls",
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
def carga_motor():
|
||||||
|
spec = importlib.util.spec_from_file_location("acciones", MOTOR)
|
||||||
|
m = importlib.util.module_from_spec(spec)
|
||||||
|
spec.loader.exec_module(m)
|
||||||
|
return m
|
||||||
|
|
||||||
|
|
||||||
|
def spawn():
|
||||||
|
return ["flatpak-spawn", "--host"] if os.path.exists("/.flatpak-info") else []
|
||||||
|
|
||||||
|
|
||||||
|
def tiene_efecto(comando: str) -> bool:
|
||||||
|
return any(marca in comando for marca in EFECTOS)
|
||||||
|
|
||||||
|
|
||||||
|
def ejecuta_crudo(comando: str, argumento: str = "") -> tuple:
|
||||||
|
"""Corre el comando en el host y devuelve (salida, codigo)."""
|
||||||
|
c = comando.replace("{argumento}", shlex.quote(argumento))
|
||||||
|
c = c.replace("{argumento_url}", shlex.quote(argumento))
|
||||||
|
try:
|
||||||
|
r = subprocess.run(spawn() + ["bash", "-lc", c],
|
||||||
|
capture_output=True, text=True, timeout=15)
|
||||||
|
return (r.stdout or r.stderr or "").strip(), r.returncode
|
||||||
|
except subprocess.TimeoutExpired:
|
||||||
|
return "TIMEOUT", 124
|
||||||
|
except OSError as e:
|
||||||
|
return f"ERROR: {e}", 1
|
||||||
|
|
||||||
|
|
||||||
|
def clasifica(motor, accion, salida, codigo):
|
||||||
|
"""A partir de la salida cruda, decide como quedaria la respuesta hablada."""
|
||||||
|
plantilla = accion.respuesta
|
||||||
|
dicho = motor.formatea(plantilla, salida, "")
|
||||||
|
|
||||||
|
# ¿la plantilla cayo al volcado crudo? formatea() devuelve {salida} cuando
|
||||||
|
# el .format() peta por un campo que no existe. Se detecta comparando: si
|
||||||
|
# la respuesta ES la salida y la plantilla NO era {salida}, fallo.
|
||||||
|
campos = re.findall(r"\{(campo\d+|ultima|primera)\}", plantilla)
|
||||||
|
if campos and dicho.strip() == salida[:600].strip() and plantilla.strip() not in ("{salida}", "{salida}."):
|
||||||
|
return "PLANTILLA", dicho
|
||||||
|
if not salida:
|
||||||
|
return "VACIA", dicho
|
||||||
|
if codigo != 0 and ("command not found" in salida or "No such file" in salida
|
||||||
|
or salida.startswith("ERROR") or salida == "TIMEOUT"):
|
||||||
|
return "ROTA", dicho
|
||||||
|
return "OK", dicho
|
||||||
|
|
||||||
|
|
||||||
|
def main():
|
||||||
|
ap = argparse.ArgumentParser()
|
||||||
|
ap.add_argument("--romper", action="store_true", help="solo las que fallan")
|
||||||
|
ap.add_argument("--json", action="store_true", help="salida en json")
|
||||||
|
args = ap.parse_args()
|
||||||
|
|
||||||
|
motor = carga_motor()
|
||||||
|
catalogo = CATALOGO if os.path.exists(CATALOGO) else CATALOGO_FUENTE
|
||||||
|
cat = motor.Catalogo([catalogo])
|
||||||
|
|
||||||
|
resultados = []
|
||||||
|
for accion in cat.acciones:
|
||||||
|
estado = None
|
||||||
|
if accion.confirmar:
|
||||||
|
estado = "EFECTO" if not accion.comando else "DESTRUCTIVA"
|
||||||
|
dicho = accion.acuse
|
||||||
|
elif tiene_efecto(accion.comando):
|
||||||
|
estado = "EFECTO"
|
||||||
|
dicho = "(no se ejecuta; " + ("comando ok" if accion.comando else "sin comando") + ")"
|
||||||
|
else:
|
||||||
|
arg = ARGUMENTOS.get(accion.id, "") if accion.captura else ""
|
||||||
|
salida, codigo = ejecuta_crudo(accion.comando, arg)
|
||||||
|
estado, dicho = clasifica(motor, accion, salida, codigo)
|
||||||
|
|
||||||
|
resultados.append({
|
||||||
|
"id": accion.id, "grupo": accion.grupo, "estado": estado,
|
||||||
|
"dice": dicho[:120],
|
||||||
|
})
|
||||||
|
|
||||||
|
cuenta = {}
|
||||||
|
for r in resultados:
|
||||||
|
cuenta[r["estado"]] = cuenta.get(r["estado"], 0) + 1
|
||||||
|
|
||||||
|
if args.json:
|
||||||
|
print(json.dumps({"cuenta": cuenta, "acciones": resultados},
|
||||||
|
ensure_ascii=False))
|
||||||
|
else:
|
||||||
|
malas = {"ROTA", "PLANTILLA", "VACIA"}
|
||||||
|
for r in resultados:
|
||||||
|
if args.romper and r["estado"] not in malas:
|
||||||
|
continue
|
||||||
|
marca = {"OK": " ok ", "VACIA": " vacia", "ROTA": " ROTA ",
|
||||||
|
"PLANTILLA": " PLANT", "EFECTO": " efect",
|
||||||
|
"DESTRUCTIVA": " destr"}.get(r["estado"], " ? ")
|
||||||
|
print(f"[{marca}] {r['id']:<22} {r['dice']}")
|
||||||
|
print("\n" + " ".join(f"{k}: {v}" for k, v in sorted(cuenta.items())))
|
||||||
|
buenas = cuenta.get("OK", 0) + cuenta.get("EFECTO", 0) + cuenta.get("DESTRUCTIVA", 0)
|
||||||
|
print(f"utiles: {buenas}/{len(resultados)} · "
|
||||||
|
f"a revisar: {sum(cuenta.get(k, 0) for k in ('ROTA','PLANTILLA','VACIA'))}")
|
||||||
|
|
||||||
|
os.makedirs(os.path.dirname(INFORME), exist_ok=True)
|
||||||
|
with open(INFORME, "w") as f:
|
||||||
|
json.dump({"cuenta": cuenta, "acciones": resultados}, f,
|
||||||
|
indent=2, ensure_ascii=False)
|
||||||
|
|
||||||
|
fallan = sum(cuenta.get(k, 0) for k in ("ROTA", "PLANTILLA"))
|
||||||
|
return 1 if fallan else 0
|
||||||
|
|
||||||
|
|
||||||
|
if __name__ == "__main__":
|
||||||
|
sys.exit(main())
|
||||||
79
config/probar_rag.py
Normal file
79
config/probar_rag.py
Normal file
|
|
@ -0,0 +1,79 @@
|
||||||
|
#!/usr/bin/env python3
|
||||||
|
"""Comprueba que el RAG recupera de tus notas, con preguntas de prueba.
|
||||||
|
|
||||||
|
flatpak run --command=python3 io.github.qwersyk.Newelle//master \
|
||||||
|
~/COFRE/CODERS/JARVIS/config/probar_rag.py
|
||||||
|
|
||||||
|
Lanza unas cuantas consultas contra el indice ya construido y enseña de que
|
||||||
|
ficheros saca la respuesta. Sirve para ver si el corpus responde bien antes de
|
||||||
|
fiarse de el, y para decidir si merece ampliarlo con los .txt o dejarlo en solo
|
||||||
|
notas.
|
||||||
|
"""
|
||||||
|
import os
|
||||||
|
import sys
|
||||||
|
import time
|
||||||
|
|
||||||
|
sys.path.insert(0, "/app/share/newelle")
|
||||||
|
sys.path.insert(0, os.path.expanduser(
|
||||||
|
"~/.var/app/io.github.qwersyk.Newelle/config/pip"))
|
||||||
|
|
||||||
|
from gi.repository import Gio # noqa: E402
|
||||||
|
|
||||||
|
from newelle.handlers.rag.llamaindex_handler import LlamaIndexHanlder # noqa: E402
|
||||||
|
from newelle.handlers.embeddings.model2vec import Model2VecHandler # noqa: E402
|
||||||
|
|
||||||
|
MODELOS = os.path.expanduser("~/.var/app/io.github.qwersyk.Newelle/config/models")
|
||||||
|
|
||||||
|
# Preguntas de dominio: si el corpus sirve, deberian traer notas relevantes.
|
||||||
|
PREGUNTAS = [
|
||||||
|
"como enumerar un host con nmap",
|
||||||
|
"escalada de privilegios en linux",
|
||||||
|
"que es oasis y como funciona el pub",
|
||||||
|
"reverse shell",
|
||||||
|
]
|
||||||
|
|
||||||
|
|
||||||
|
def main():
|
||||||
|
settings = Gio.Settings.new("io.github.qwersyk.Newelle")
|
||||||
|
rag = LlamaIndexHanlder(settings, MODELOS)
|
||||||
|
if not rag.is_installed():
|
||||||
|
print("faltan dependencias del RAG")
|
||||||
|
return 1
|
||||||
|
|
||||||
|
rag.embedding = Model2VecHandler(settings, MODELOS)
|
||||||
|
|
||||||
|
class SinModelo:
|
||||||
|
def load_model(self, *a, **k):
|
||||||
|
return True
|
||||||
|
rag.llm = SinModelo()
|
||||||
|
rag.secondary_llm = SinModelo()
|
||||||
|
|
||||||
|
print("cargando el indice...", flush=True)
|
||||||
|
try:
|
||||||
|
rag.load_index()
|
||||||
|
except Exception as e:
|
||||||
|
print(f"no se pudo cargar el indice: {e}")
|
||||||
|
return 1
|
||||||
|
|
||||||
|
for pregunta in PREGUNTAS:
|
||||||
|
print(f"\n### {pregunta}")
|
||||||
|
ini = time.time()
|
||||||
|
try:
|
||||||
|
trozos = rag.get_context(pregunta, [])
|
||||||
|
except Exception as e:
|
||||||
|
print(f" fallo: {e}")
|
||||||
|
continue
|
||||||
|
ms = (time.time() - ini) * 1000
|
||||||
|
if not trozos:
|
||||||
|
print(f" sin resultados ({ms:.0f} ms)")
|
||||||
|
continue
|
||||||
|
print(f" {len(trozos)} trozos en {ms:.0f} ms:")
|
||||||
|
for t in trozos[:1]:
|
||||||
|
# el trozo suele traer la ruta o el nombre del fichero delante
|
||||||
|
resumen = " ".join(str(t).split())[:400]
|
||||||
|
print(f" · {resumen}")
|
||||||
|
return 0
|
||||||
|
|
||||||
|
|
||||||
|
if __name__ == "__main__":
|
||||||
|
sys.exit(main())
|
||||||
51
config/probar_rag_temas.py
Normal file
51
config/probar_rag_temas.py
Normal file
|
|
@ -0,0 +1,51 @@
|
||||||
|
#!/usr/bin/env python3
|
||||||
|
"""Prueba el RAG con los temas recien ingestados de Wikipedia."""
|
||||||
|
import os, sys, time
|
||||||
|
sys.path.insert(0, "/app/share/newelle")
|
||||||
|
sys.path.insert(0, os.path.expanduser(
|
||||||
|
"~/.var/app/io.github.qwersyk.Newelle/config/pip"))
|
||||||
|
from gi.repository import Gio # noqa: E402
|
||||||
|
from newelle.handlers.rag.llamaindex_handler import LlamaIndexHanlder # noqa
|
||||||
|
from newelle.handlers.embeddings.model2vec import Model2VecHandler # noqa
|
||||||
|
|
||||||
|
MODELOS = os.path.expanduser("~/.var/app/io.github.qwersyk.Newelle/config/models")
|
||||||
|
PREGUNTAS = [
|
||||||
|
"que es la criptografia de curva eliptica",
|
||||||
|
"quien es Richard Stallman y el software libre",
|
||||||
|
"que es el efecto invernadero y el cambio climatico",
|
||||||
|
"que fue la guerra civil espanola",
|
||||||
|
"que es un ataque de denegacion de servicio",
|
||||||
|
]
|
||||||
|
|
||||||
|
|
||||||
|
def main():
|
||||||
|
settings = Gio.Settings.new("io.github.qwersyk.Newelle")
|
||||||
|
rag = LlamaIndexHanlder(settings, MODELOS)
|
||||||
|
if not rag.is_installed():
|
||||||
|
print("faltan dependencias del RAG"); return 1
|
||||||
|
rag.embedding = Model2VecHandler(settings, MODELOS)
|
||||||
|
|
||||||
|
class SinModelo:
|
||||||
|
def load_model(self, *a, **k): return True
|
||||||
|
rag.llm = SinModelo(); rag.secondary_llm = SinModelo()
|
||||||
|
print("cargando el indice...", flush=True)
|
||||||
|
rag.load_index()
|
||||||
|
for pregunta in PREGUNTAS:
|
||||||
|
print(f"\n### {pregunta}")
|
||||||
|
ini = time.time()
|
||||||
|
try:
|
||||||
|
trozos = rag.get_context(pregunta, [])
|
||||||
|
except Exception as e:
|
||||||
|
print(f" fallo: {e}"); continue
|
||||||
|
ms = (time.time() - ini) * 1000
|
||||||
|
if not trozos:
|
||||||
|
print(f" sin resultados ({ms:.0f} ms)"); continue
|
||||||
|
print(f" {len(trozos)} trozos en {ms:.0f} ms:")
|
||||||
|
for t in trozos[:2]:
|
||||||
|
resumen = " ".join(str(t).split())[:280]
|
||||||
|
print(f" · {resumen}")
|
||||||
|
return 0
|
||||||
|
|
||||||
|
|
||||||
|
if __name__ == "__main__":
|
||||||
|
sys.exit(main())
|
||||||
227
config/proponer_alias.py
Executable file
227
config/proponer_alias.py
Executable file
|
|
@ -0,0 +1,227 @@
|
||||||
|
#!/usr/bin/env python3
|
||||||
|
"""Saca alias de lo que el usuario dijo y JARVIS no entendio.
|
||||||
|
|
||||||
|
Es la fuente mas valiosa de mejora porque son fallos REALES: el panel apunta en
|
||||||
|
jarvis-sin-accion.jsonl toda frase que no encajo en ninguna accion. Con 488
|
||||||
|
lineas acumuladas y nadie leyendolas, ahi habia meses de mejoras sin recoger.
|
||||||
|
|
||||||
|
Lo dificil no es proponer, es NO proponer de mas. Un alias malo desvia una
|
||||||
|
orden buena, y eso es peor que no entender: el usuario dice una cosa y pasa
|
||||||
|
otra. Los filtros de abajo son casi todo el fichero por esa razon.
|
||||||
|
|
||||||
|
proponer_alias.py enseña lo que propondria
|
||||||
|
proponer_alias.py --aplicar lo escribe en el generador
|
||||||
|
"""
|
||||||
|
import argparse
|
||||||
|
import collections
|
||||||
|
import difflib
|
||||||
|
import importlib.util
|
||||||
|
import json
|
||||||
|
import os
|
||||||
|
import re
|
||||||
|
import sys
|
||||||
|
|
||||||
|
RAIZ = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
|
||||||
|
REGISTRO = os.path.expanduser(
|
||||||
|
"~/.var/app/io.github.qwersyk.Newelle/config/jarvis-sin-accion.jsonl")
|
||||||
|
CATALOGO = os.path.join(RAIZ, "newelle", "data", "acciones", "acciones.json")
|
||||||
|
MOTOR = os.path.join(RAIZ, "newelle", "src", "utility", "acciones.py")
|
||||||
|
APLICADOS = os.path.join(RAIZ, "config", "alias-aplicados.json")
|
||||||
|
|
||||||
|
# Lo que dice JARVIS: si aparece en el registro es ECO —se oye a si mismo por
|
||||||
|
# el altavoz— y no es una orden de nadie. Era el 21% del registro.
|
||||||
|
def es_eco(frase, acuses):
|
||||||
|
l = frase.lower()
|
||||||
|
if "señor" in l:
|
||||||
|
return True
|
||||||
|
return any(a and a in l for a in acuses)
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
def parece_orden(frase):
|
||||||
|
"""Un filtro barato antes de gastar el modelo: ¿esto pide algo?
|
||||||
|
|
||||||
|
La charla no lleva verbo de mando. Sin este filtro entran cosas como
|
||||||
|
"Me estas escuchando" o "y que te voy a hacer", que por parecido de letras
|
||||||
|
puntuan alto con cualquier frase corta del catalogo.
|
||||||
|
"""
|
||||||
|
l = " " + frase.lower() + " "
|
||||||
|
VERBOS = (" pon ", " ponme ", " pongas ", " poner ", " abre ", " abreme ",
|
||||||
|
" abrir ", " abras ", " busca ", " buscame ", " buscar ", " busques ",
|
||||||
|
" dime ", " dame ", " muestra ", " muestrame ", " ensename ",
|
||||||
|
" ejecuta ", " lanza ", " haz ", " hazme ", " mira ", " comprueba ",
|
||||||
|
" cierra ", " manda ", " pasa ", " mueve ", " maximiza ", " minimiza ",
|
||||||
|
" centra ", " reproduce ", " cuanto ", " cuanta ", " cuantos ",
|
||||||
|
" cuantas ", " que hora ", " donde ", " cual ")
|
||||||
|
return any(v in l for v in VERBOS)
|
||||||
|
|
||||||
|
|
||||||
|
def el_modelo_lo_confirma(frase, accion, modelo="qwen3.5:4b-jarvis"):
|
||||||
|
"""Que un modelo diga si la frase pide de verdad esa accion.
|
||||||
|
|
||||||
|
El parecido de letras no distingue significado: "me estas escuchando" saca
|
||||||
|
0.57 con las frases de la accion de puertos, y con eso se colaria un alias
|
||||||
|
que desvia ordenes buenas. Un alias malo es peor que no entender, porque el
|
||||||
|
usuario pide una cosa y pasa otra.
|
||||||
|
|
||||||
|
Ante la duda, NO. Si el modelo no contesta o contesta cualquier cosa, se
|
||||||
|
descarta: dejar pasar un alias dudoso cuesta mas que perderlo.
|
||||||
|
"""
|
||||||
|
import urllib.request
|
||||||
|
ejemplo = accion.frases[0] if accion.frases else accion.id
|
||||||
|
prompt = (
|
||||||
|
"Decide si dos frases piden LO MISMO. Responde solo SI o NO.\n\n"
|
||||||
|
"Ejemplos:\n"
|
||||||
|
"A: \"cuanto espacio queda\" B: \"dime cuanto disco me queda\" -> SI\n"
|
||||||
|
"A: \"cuanto espacio queda\" B: \"que tal estas\" -> NO\n"
|
||||||
|
"A: \"abre una terminal\" B: \"sacame una consola\" -> SI\n"
|
||||||
|
"A: \"abre una terminal\" B: \"me estas escuchando\" -> NO\n"
|
||||||
|
"A: \"que temperatura hay\" B: \"cuentame un chiste\" -> NO\n\n"
|
||||||
|
f"A: \"{ejemplo}\" B: \"{frase}\" -> "
|
||||||
|
)
|
||||||
|
try:
|
||||||
|
carga = json.dumps({"model": modelo, "prompt": prompt, "stream": False,
|
||||||
|
"think": False, "options": {"temperature": 0}}).encode()
|
||||||
|
req = urllib.request.Request("http://127.0.0.1:11434/api/generate",
|
||||||
|
data=carga,
|
||||||
|
headers={"Content-Type": "application/json"})
|
||||||
|
with urllib.request.urlopen(req, timeout=120) as r:
|
||||||
|
respuesta = json.load(r).get("response", "").strip().upper()
|
||||||
|
except Exception:
|
||||||
|
return False
|
||||||
|
return respuesta.startswith("SI") or respuesta.startswith("SÍ")
|
||||||
|
|
||||||
|
|
||||||
|
def cargar_motor():
|
||||||
|
spec = importlib.util.spec_from_file_location("acciones", MOTOR)
|
||||||
|
m = importlib.util.module_from_spec(spec)
|
||||||
|
spec.loader.exec_module(m)
|
||||||
|
return m
|
||||||
|
|
||||||
|
|
||||||
|
def frases_del_registro():
|
||||||
|
if not os.path.exists(REGISTRO):
|
||||||
|
return []
|
||||||
|
fuera = []
|
||||||
|
for linea in open(REGISTRO, encoding="utf-8"):
|
||||||
|
try:
|
||||||
|
t = json.loads(linea).get("texto", "")
|
||||||
|
except Exception:
|
||||||
|
t = linea.strip()
|
||||||
|
t = " ".join(t.split())
|
||||||
|
if t:
|
||||||
|
fuera.append(t)
|
||||||
|
return fuera
|
||||||
|
|
||||||
|
|
||||||
|
def main():
|
||||||
|
p = argparse.ArgumentParser()
|
||||||
|
p.add_argument("--aplicar", action="store_true")
|
||||||
|
p.add_argument("--tope", type=int, default=3,
|
||||||
|
help="cuantos alias como mucho por vuelta")
|
||||||
|
args = p.parse_args()
|
||||||
|
|
||||||
|
m = cargar_motor()
|
||||||
|
cat = m.Catalogo([CATALOGO])
|
||||||
|
acciones = {a.id: a for a in cat.acciones}
|
||||||
|
acuses = {a.acuse.lower().strip(". ") for a in cat.acciones if a.acuse}
|
||||||
|
|
||||||
|
frases = frases_del_registro()
|
||||||
|
if not frases:
|
||||||
|
print("no hay registro de frases sin entender")
|
||||||
|
return 1
|
||||||
|
|
||||||
|
try:
|
||||||
|
ya = set(json.load(open(APLICADOS)))
|
||||||
|
except Exception:
|
||||||
|
ya = set()
|
||||||
|
|
||||||
|
# 1. fuera el eco y lo que ya se entiende hoy (el catalogo cambia)
|
||||||
|
candidatas = []
|
||||||
|
for f in frases:
|
||||||
|
if f in ya or es_eco(f, acuses):
|
||||||
|
continue
|
||||||
|
if cat.busca(f)[0] is not None:
|
||||||
|
continue
|
||||||
|
candidatas.append(f)
|
||||||
|
|
||||||
|
# 2. lo que se repite es lo que importa: una frase dicha una vez puede ser
|
||||||
|
# un error de transcripcion; dicha tres veces es como habla el usuario
|
||||||
|
cuenta = collections.Counter(candidatas)
|
||||||
|
|
||||||
|
propuestas = []
|
||||||
|
for frase, veces in cuenta.most_common():
|
||||||
|
norm = m.normaliza(frase)
|
||||||
|
palabras = norm.split()
|
||||||
|
# 3. filtros duros
|
||||||
|
if not (3 <= len(palabras) <= 12):
|
||||||
|
continue
|
||||||
|
if re.search(r"[<>{}\[\]|@#_*]", frase):
|
||||||
|
continue
|
||||||
|
# 4. a que accion se parece mas, comparando con TODAS sus frases
|
||||||
|
mejor, punto = None, 0.0
|
||||||
|
for a in cat.acciones:
|
||||||
|
if a.captura:
|
||||||
|
continue # el relleno de prueba se horneraria en el alias
|
||||||
|
for f2 in a.frases:
|
||||||
|
r = difflib.SequenceMatcher(None, norm, f2).ratio()
|
||||||
|
if r > punto:
|
||||||
|
mejor, punto = a, r
|
||||||
|
# 5. ni muy lejos (seria inventarse) ni muy cerca (ya lo cogeria)
|
||||||
|
if mejor is None or not (0.55 <= punto < 0.86):
|
||||||
|
continue
|
||||||
|
# 6. tiene que compartir una palabra con significado, o el alias
|
||||||
|
# convierte cualquier ruido en una orden
|
||||||
|
suyas = {w for f2 in mejor.frases for w in f2.split() if len(w) > 3}
|
||||||
|
if not (set(w for w in palabras if len(w) > 3) & suyas):
|
||||||
|
continue
|
||||||
|
# 7. y no puede encajar en dos acciones a la vez
|
||||||
|
otras = [a for a in cat.acciones
|
||||||
|
if a is not mejor and not a.captura
|
||||||
|
and max((difflib.SequenceMatcher(None, norm, f2).ratio()
|
||||||
|
for f2 in a.frases), default=0) >= punto - 0.05]
|
||||||
|
if otras:
|
||||||
|
continue
|
||||||
|
# 8. tiene que parecer una orden, no charla
|
||||||
|
if not parece_orden(frase):
|
||||||
|
continue
|
||||||
|
# 9. y el modelo tiene que confirmar que pide ESA accion. Es lo unico
|
||||||
|
# que distingue significado de coincidencia de letras.
|
||||||
|
if not el_modelo_lo_confirma(frase, mejor):
|
||||||
|
continue
|
||||||
|
propuestas.append((frase, norm, mejor.id, punto, veces))
|
||||||
|
|
||||||
|
if not propuestas:
|
||||||
|
print("nada que proponer: ninguna frase pasa los filtros")
|
||||||
|
return 1
|
||||||
|
|
||||||
|
propuestas = propuestas[:args.tope]
|
||||||
|
for frase, norm, ident, punto, veces in propuestas:
|
||||||
|
print(f" {ident:22s} ← \"{frase[:52]}\" (x{veces}, parecido {punto:.2f})")
|
||||||
|
|
||||||
|
if not args.aplicar:
|
||||||
|
return 0
|
||||||
|
|
||||||
|
# 8. se escribe en el GENERADOR, que es la fuente. Editar el JSON seria
|
||||||
|
# perder el cambio la proxima vez que alguien regenere.
|
||||||
|
gen = os.path.join(RAIZ, "newelle", "data", "acciones", "_generar.py")
|
||||||
|
texto = open(gen, encoding="utf-8").read()
|
||||||
|
puestos = 0
|
||||||
|
for frase, norm, ident, punto, veces in propuestas:
|
||||||
|
patron = re.compile(r'(\("' + re.escape(ident) + r'", ")([^"]*)(")')
|
||||||
|
mm = patron.search(texto)
|
||||||
|
if not mm or norm in mm.group(2):
|
||||||
|
continue
|
||||||
|
texto = texto[:mm.start(2)] + mm.group(2) + "|" + norm + texto[mm.end(2):]
|
||||||
|
puestos += 1
|
||||||
|
ya.add(frase)
|
||||||
|
if puestos:
|
||||||
|
open(gen, "w", encoding="utf-8").write(texto)
|
||||||
|
os.system(f"cd {os.path.dirname(gen)} && python3 _generar.py >/dev/null 2>&1")
|
||||||
|
json.dump(sorted(ya), open(APLICADOS, "w"), ensure_ascii=False, indent=1)
|
||||||
|
print(f"{puestos} alias aplicados al generador")
|
||||||
|
return 0 if puestos else 1
|
||||||
|
|
||||||
|
|
||||||
|
if __name__ == "__main__":
|
||||||
|
sys.exit(main())
|
||||||
15
config/proponer_frases.py
Executable file
15
config/proponer_frases.py
Executable file
|
|
@ -0,0 +1,15 @@
|
||||||
|
#!/usr/bin/env python3
|
||||||
|
"""Variantes de las frases del catalogo, generadas con el modelo local.
|
||||||
|
|
||||||
|
Sitio reservado: hoy el trabajo util lo hace proponer_alias.py, que parte de
|
||||||
|
fallos REALES del usuario. Generar variantes inventadas sin datos detras llena
|
||||||
|
el catalogo de ruido y sube el riesgo de que una frase se coma a otra, que es
|
||||||
|
el fallo mas caro del emparejador.
|
||||||
|
|
||||||
|
Cuando haya mas registro de uso, aqui ira: coger las acciones que nunca se
|
||||||
|
disparan, pedirle al modelo tres formas mas de pedirlas, y pasarlas por el
|
||||||
|
mismo juez que usa proponer_alias.
|
||||||
|
"""
|
||||||
|
import sys
|
||||||
|
print("sin datos suficientes: se propone desde fallos reales, no inventando")
|
||||||
|
sys.exit(1)
|
||||||
108
config/puerta.sh
Executable file
108
config/puerta.sh
Executable file
|
|
@ -0,0 +1,108 @@
|
||||||
|
#!/usr/bin/env bash
|
||||||
|
# La puerta: decide si un cambio automatico se queda o se revierte.
|
||||||
|
#
|
||||||
|
# Es la pieza central del pipeline nocturno. Todo lo que el sistema se cambia a
|
||||||
|
# si mismo pasa por aqui, y lo que no la pasa se deshace ENTERO. Sin esto,
|
||||||
|
# dejar algo modificando codigo sin nadie delante es una forma elaborada de
|
||||||
|
# romper un proyecto que funcionaba.
|
||||||
|
#
|
||||||
|
# Que comprueba, en orden de lo mas barato a lo mas caro (para fallar pronto):
|
||||||
|
# 1. que el Python compile
|
||||||
|
# 2. que el catalogo sea JSON valido y el generador lo reproduzca
|
||||||
|
# 3. que el emparejador no haya perdido ordenes (08)
|
||||||
|
# 4. que las acciones sigan respondiendo (repaso completo)
|
||||||
|
# 5. la suite entera
|
||||||
|
#
|
||||||
|
# puerta.sh rapida solo 1-3, para iterar
|
||||||
|
# puerta.sh completa todo, antes de commitear
|
||||||
|
set -uo pipefail
|
||||||
|
RAIZ=$(cd -P "$(dirname "${BASH_SOURCE[0]:-$0}")/.." && pwd)
|
||||||
|
MODO=${1:-completa}
|
||||||
|
cd "$RAIZ"
|
||||||
|
|
||||||
|
fallo() { echo "PUERTA: $1" >&2; exit 1; }
|
||||||
|
|
||||||
|
# --- 1. compila el Python -------------------------------------------------
|
||||||
|
python3 -m compileall -q newelle/src config voz/*.py >/dev/null 2>&1 \
|
||||||
|
|| fallo "hay Python que no compila"
|
||||||
|
|
||||||
|
# --- 2. el catalogo es valido y reproducible ------------------------------
|
||||||
|
python3 -c "
|
||||||
|
import json,sys
|
||||||
|
d=json.load(open('newelle/data/acciones/acciones.json'))
|
||||||
|
acc=d['acciones']
|
||||||
|
assert len(acc)>100, f'solo {len(acc)} acciones'
|
||||||
|
ids=[a['id'] for a in acc]
|
||||||
|
assert len(ids)==len(set(ids)), 'ids repetidos'
|
||||||
|
for a in acc:
|
||||||
|
assert a.get('frases'), f\"{a['id']} sin frases\"
|
||||||
|
assert a.get('acuse'), f\"{a['id']} sin acuse\"
|
||||||
|
assert 'señor' in a['acuse'].lower(), f\"{a['id']} no trata de señor\"
|
||||||
|
if a.get('captura') and a.get('comando'):
|
||||||
|
assert '{argumento' in a['comando'], f\"{a['id']} captura y no usa el argumento\"
|
||||||
|
" 2>/dev/null || fallo "el catalogo esta mal formado"
|
||||||
|
|
||||||
|
# El generador es la fuente: si no reproduce el catalogo, alguien edito el
|
||||||
|
# producto y el proximo que regenere pierde el trabajo.
|
||||||
|
cp newelle/data/acciones/acciones.json /tmp/jarvis-puerta-antes.json
|
||||||
|
(cd newelle/data/acciones && python3 _generar.py >/dev/null 2>&1)
|
||||||
|
if ! diff -q /tmp/jarvis-puerta-antes.json newelle/data/acciones/acciones.json >/dev/null 2>&1; then
|
||||||
|
cp /tmp/jarvis-puerta-antes.json newelle/data/acciones/acciones.json
|
||||||
|
fallo "el generador no reproduce el catalogo (se edito el producto)"
|
||||||
|
fi
|
||||||
|
|
||||||
|
# --- 3. el emparejador no ha perdido ordenes ------------------------------
|
||||||
|
python3 - <<'FIN' || fallo "el emparejador ha perdido ordenes que antes acertaba"
|
||||||
|
import importlib.util, sys
|
||||||
|
spec = importlib.util.spec_from_file_location("acc", "newelle/src/utility/acciones.py")
|
||||||
|
m = importlib.util.module_from_spec(spec); spec.loader.exec_module(m)
|
||||||
|
cat = m.Catalogo(["newelle/data/acciones/acciones.json"])
|
||||||
|
|
||||||
|
# El minimo innegociable: si alguna de estas deja de funcionar, el cambio se
|
||||||
|
# revierte pase lo que pase. Son las que el usuario usa de verdad.
|
||||||
|
IMPRESCINDIBLES = [
|
||||||
|
("cuanto espacio queda", "disco_libre"),
|
||||||
|
("cuanta memoria", "memoria"),
|
||||||
|
("que temperatura hay", "temperatura"),
|
||||||
|
("abre una terminal", "terminal_abrir"),
|
||||||
|
("apaga la pantalla", "apagar_pantalla"),
|
||||||
|
("captura de pantalla", "captura_pantalla"),
|
||||||
|
("abre una ventana privada", "ff_firefox_privado"),
|
||||||
|
("pon la ventana a la izquierda", "ventana_izquierda"),
|
||||||
|
("necesito que pongas la pelicula de iron man", "pelicula_abrir"),
|
||||||
|
("podrias abrir una terminal", "terminal_abrir"),
|
||||||
|
]
|
||||||
|
malas = []
|
||||||
|
for frase, esperado in IMPRESCINDIBLES:
|
||||||
|
a, _ = cat.busca(frase)
|
||||||
|
if a is None or a.id != esperado:
|
||||||
|
malas.append(f"{frase!r}→{a.id if a else 'ninguna'} (deberia {esperado})")
|
||||||
|
|
||||||
|
# Y la conversacion no puede engancharse a una accion
|
||||||
|
CHARLA = ["que tal estas", "necesito un abrazo", "quiero contarte una cosa",
|
||||||
|
"cuentame un chiste", "que piensas de la vida", "necesito pensar"]
|
||||||
|
coladas = [c for c in CHARLA if cat.busca(c)[0] is not None]
|
||||||
|
if malas or coladas:
|
||||||
|
for x in malas: print(" perdida:", x, file=sys.stderr)
|
||||||
|
for c in coladas: print(" charla colada:", c, file=sys.stderr)
|
||||||
|
sys.exit(1)
|
||||||
|
FIN
|
||||||
|
|
||||||
|
[ "$MODO" = rapida ] && { echo "PUERTA: rapida OK"; exit 0; }
|
||||||
|
|
||||||
|
# --- 4. las acciones responden -------------------------------------------
|
||||||
|
SALIDA=$(timeout 900 python3 config/repasar_acciones.py 2>&1 | tail -3)
|
||||||
|
echo "$SALIDA" | grep -q "de .* responden bien" || fallo "el repaso de acciones no termino"
|
||||||
|
ROTAS=$(echo "$SALIDA" | grep -oE "fallan: .*" || true)
|
||||||
|
[ -n "$ROTAS" ] && fallo "hay acciones rotas → $ROTAS"
|
||||||
|
|
||||||
|
# --- 5. la suite ----------------------------------------------------------
|
||||||
|
# Se salta la 07, que abre la app y se queda colgada sin nadie delante.
|
||||||
|
SUITE=$(cd pruebas && for t in [0-9][0-9]_*.sh; do
|
||||||
|
case "$t" in 05_*|07_*) continue;; esac
|
||||||
|
timeout 400 "./$t" 2>&1 | tail -1
|
||||||
|
done)
|
||||||
|
FALLOS=$(echo "$SUITE" | grep -oE "[0-9]+ fallan" | awk '{s+=$1} END{print s+0}')
|
||||||
|
[ "${FALLOS:-0}" -gt 0 ] && fallo "la suite tiene $FALLOS comprobaciones en rojo"
|
||||||
|
|
||||||
|
echo "PUERTA: completa OK"
|
||||||
18
config/qwen3.5-4b-jarvis.Modelfile
Normal file
18
config/qwen3.5-4b-jarvis.Modelfile
Normal file
|
|
@ -0,0 +1,18 @@
|
||||||
|
# Variante de qwen3.5:4b para JARVIS: deja sitio a whisper en la tarjeta.
|
||||||
|
#
|
||||||
|
# La T1200 tiene 3717 MiB utiles. Con el reparto automatico ollama coge 2941 y
|
||||||
|
# deja 776 libres: whisper small CARGA (757) pero se mata al transcribir, cuando
|
||||||
|
# pide su pico de 839. El sintoma en la app es "Error recognizing file with
|
||||||
|
# server", que despista, porque el fichero y el servidor estan bien.
|
||||||
|
#
|
||||||
|
# Con 24 de las 32 capas en GPU el LLM ocupa 2177 y deja 1540 libres: caben los
|
||||||
|
# dos con 700 MiB de holgura. Y no cuesta velocidad — medido con tres tiradas en
|
||||||
|
# caliente, la respuesta baja de 2,71 s a 2,31 s, porque el reparto automatico
|
||||||
|
# se queda sin VRAM y acaba peleandose consigo mismo.
|
||||||
|
#
|
||||||
|
# Crear o recrear: ollama create qwen3.5:4b-jarvis -f qwen3.5-4b-jarvis.Modelfile
|
||||||
|
|
||||||
|
FROM qwen3.5:4b
|
||||||
|
|
||||||
|
PARAMETER num_gpu 24
|
||||||
|
PARAMETER num_ctx 4096
|
||||||
114
config/recorrido.sh
Executable file
114
config/recorrido.sh
Executable file
|
|
@ -0,0 +1,114 @@
|
||||||
|
#!/usr/bin/env bash
|
||||||
|
# Recorre el catalogo grupo por grupo, en voz alta y a ritmo de mirar.
|
||||||
|
#
|
||||||
|
# Distinto de demo_en_directo.sh: aquel probaba once acciones sueltas; este
|
||||||
|
# recorre TODOS los grupos con una muestra representativa de cada uno, anuncia
|
||||||
|
# el grupo antes de entrar, y deja pausas para que se pueda seguir en pantalla.
|
||||||
|
#
|
||||||
|
# Lo destructivo y lo que pide root no se ejecuta: en uso normal eso pasa por
|
||||||
|
# un dialogo que aprueba una persona.
|
||||||
|
#
|
||||||
|
# ./recorrido.sh todo, con voz
|
||||||
|
# ./recorrido.sh --mudo sin voz
|
||||||
|
# ./recorrido.sh sistema solo un grupo
|
||||||
|
set -uo pipefail
|
||||||
|
RAIZ=$(cd -P "$(dirname "${BASH_SOURCE[0]:-$0}")/.." && pwd)
|
||||||
|
CATALOGO=$RAIZ/newelle/data/acciones/acciones.json
|
||||||
|
MUDO=no; SOLO=""
|
||||||
|
for a in "$@"; do
|
||||||
|
case "$a" in --mudo) MUDO=si;; *) SOLO=$a;; esac
|
||||||
|
done
|
||||||
|
WAV=$(mktemp --suffix=.wav); trap 'rm -f "$WAV"' EXIT
|
||||||
|
|
||||||
|
dice() {
|
||||||
|
[ "$MUDO" = si ] && { sleep 0.4; return 0; }
|
||||||
|
"$RAIZ/config/jarvis-voz.sh" "$WAV" "$1" >/dev/null 2>&1
|
||||||
|
# < /dev/null: si no, se comen la entrada del bucle que los llama
|
||||||
|
[ -s "$WAV" ] && { paplay "$WAV" </dev/null 2>/dev/null || aplay -q "$WAV" </dev/null 2>/dev/null; }
|
||||||
|
}
|
||||||
|
|
||||||
|
campo() { python3 -c "
|
||||||
|
import json,sys
|
||||||
|
d=json.load(open('$CATALOGO',encoding='utf-8'))
|
||||||
|
for a in d.get('acciones', d if isinstance(d,list) else []):
|
||||||
|
if a['id']==sys.argv[1]: print(a.get(sys.argv[2],'') or ''); break
|
||||||
|
" "$1" "$2"; }
|
||||||
|
|
||||||
|
# grupo|id|frase que se diria|argumento
|
||||||
|
RECORRIDO='
|
||||||
|
sistema|disco_libre|cuanto espacio queda|
|
||||||
|
sistema|memoria|cuanta memoria|
|
||||||
|
sistema|temperatura|que temperatura hay|
|
||||||
|
sistema|uptime|cuanto lleva encendido|
|
||||||
|
sistema|procesos_top|que esta consumiendo|
|
||||||
|
sistema|red_ip|cual es mi ip|
|
||||||
|
sistema|red_wifi|a que wifi estoy conectado|
|
||||||
|
sistema|gpu_procesos|que usa la grafica|
|
||||||
|
sistema|pantallas|cuantas pantallas hay|
|
||||||
|
sistema|captura_pantalla|hazme una captura|
|
||||||
|
sistema|terminal_abrir|abre una terminal|
|
||||||
|
sistema|videos_listar|que peliculas tengo|
|
||||||
|
ficheros|buscar_fichero|busca el fichero README|README.md
|
||||||
|
ficheros|grep_recursivo|busca la palabra JARVIS|JARVIS
|
||||||
|
ficheros|tamano_carpeta|cuanto ocupa la carpeta config|'"$RAIZ"'/config
|
||||||
|
ficheros|descargas_listar|que hay en descargas|
|
||||||
|
oasis|oasis_corriendo|esta oasis funcionando|
|
||||||
|
oasis|oasis_conexiones|cuantos pubs hay conectados|
|
||||||
|
pentest|mis_puertos|que puertos tengo abiertos yo|
|
||||||
|
ventanas|ventanas_listar|que ventanas tengo abiertas|
|
||||||
|
ventanas|ventana_izquierda|pon la ventana a la izquierda|
|
||||||
|
ventanas|ventana_derecha|manda la ventana a la derecha|
|
||||||
|
ventanas|ventana_centrar|centra la ventana activa|
|
||||||
|
ventanas|ventana_maximizar|maximiza la ventana activa|
|
||||||
|
ventanas|ventana_restaurar|restaura la ventana activa|
|
||||||
|
ventanas|ventana_a_pantalla|manda la ventana a la pantalla uno|uno
|
||||||
|
'
|
||||||
|
|
||||||
|
grupo_actual=""
|
||||||
|
n=0
|
||||||
|
while IFS='|' read -r -u 3 grupo id frase argumento; do
|
||||||
|
[ -z "${grupo:-}" ] && continue
|
||||||
|
[ -n "$SOLO" ] && [ "$SOLO" != "$grupo" ] && continue
|
||||||
|
|
||||||
|
if [ "$grupo" != "$grupo_actual" ]; then
|
||||||
|
grupo_actual=$grupo
|
||||||
|
printf '\n\n\033[1m ══ grupo: %s ══\033[0m\n' "$grupo"
|
||||||
|
dice "Grupo $grupo, señor."
|
||||||
|
sleep 0.6
|
||||||
|
fi
|
||||||
|
|
||||||
|
comando=$(campo "$id" comando)
|
||||||
|
[ -z "$comando" ] && { printf ' (%s no existe en el catalogo)\n' "$id"; continue; }
|
||||||
|
acuse=$(campo "$id" acuse)
|
||||||
|
plantilla=$(campo "$id" respuesta)
|
||||||
|
|
||||||
|
n=$((n+1))
|
||||||
|
printf '\n %2d. tu: "%s"\n' "$n" "$frase"
|
||||||
|
printf ' jarvis: %s\n' "$acuse"
|
||||||
|
dice "$acuse"
|
||||||
|
|
||||||
|
real=${comando//\{argumento\}/$(printf '%q' "${argumento:-}")}
|
||||||
|
salida=$(timeout 40 bash -lc "$real" </dev/null 2>&1 | head -6)
|
||||||
|
|
||||||
|
if [ -n "$salida" ]; then
|
||||||
|
echo "$salida" | sed 's/^/ /' | cut -c1-104
|
||||||
|
else
|
||||||
|
printf ' (hecho, sin salida)\n'
|
||||||
|
fi
|
||||||
|
|
||||||
|
# decir la respuesta si la plantilla se puede resolver
|
||||||
|
if [ -n "$plantilla" ] && [ -n "$salida" ]; then
|
||||||
|
ultima=$(echo "$salida" | tail -1); primera=$(echo "$salida" | head -1)
|
||||||
|
lineas=$(echo "$salida" | wc -l)
|
||||||
|
h=${plantilla//\{ultima\}/$ultima}; h=${h//\{primera\}/$primera}
|
||||||
|
h=${h//\{lineas\}/$lineas}; h=${h//\{salida\}/$salida}
|
||||||
|
case "$h" in
|
||||||
|
*"{"*) ;;
|
||||||
|
*) [ ${#h} -lt 170 ] && { printf ' jarvis: %s\n' "$h"; dice "$h"; };;
|
||||||
|
esac
|
||||||
|
fi
|
||||||
|
sleep 1.5
|
||||||
|
done 3<<< "$RECORRIDO"
|
||||||
|
|
||||||
|
printf '\n\n ── %d acciones mostradas ──\n' "$n"
|
||||||
|
dice "Recorrido terminado, señor."
|
||||||
174
config/repasar_acciones.py
Executable file
174
config/repasar_acciones.py
Executable file
|
|
@ -0,0 +1,174 @@
|
||||||
|
#!/usr/bin/env python3
|
||||||
|
"""Ejecuta TODAS las acciones del catalogo y dice cuales funcionan de verdad.
|
||||||
|
|
||||||
|
Por que hace falta: hasta hoy los comandos libres del modelo corrian dentro del
|
||||||
|
sandbox, donde no hay ni el sistema ni los discos. Se arreglo (virtualization a
|
||||||
|
false), pero las 134 acciones del catalogo nunca se habian ejecutado todas
|
||||||
|
seguidas contra la maquina real: la suite prueba que las FRASES caen en la
|
||||||
|
accion correcta, no que el comando de cada accion haga algo util.
|
||||||
|
|
||||||
|
Que se ejecuta y que no:
|
||||||
|
|
||||||
|
- Las destructivas (`confirmar: true`) y las que piden root NO se ejecutan.
|
||||||
|
En uso normal pasan por un dialogo que aprueba una persona; aqui no hay
|
||||||
|
persona, y aprobarlas solas seria justo lo que el diseño evita.
|
||||||
|
- Las que abren ventanas (firefox, xdg-open) se ejecutan solo con --abrir,
|
||||||
|
porque llenan la pantalla. Sin esa opcion se comprueba que el programa
|
||||||
|
existe, que es lo que puede fallar.
|
||||||
|
- El resto se ejecuta entero y se mira que conteste algo con sentido.
|
||||||
|
|
||||||
|
python repasar_acciones.py [--abrir] [--grupo sistema] [--json salida.json]
|
||||||
|
"""
|
||||||
|
import argparse
|
||||||
|
import json
|
||||||
|
import os
|
||||||
|
import re
|
||||||
|
import subprocess
|
||||||
|
import sys
|
||||||
|
import time
|
||||||
|
|
||||||
|
RAIZ = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
|
||||||
|
CATALOGO = os.path.join(RAIZ, "newelle", "data", "acciones", "acciones.json")
|
||||||
|
|
||||||
|
# Argumentos de mentira para las acciones que capturan uno. Se eligen inocuos:
|
||||||
|
# nada que borre, mueva o mande nada fuera.
|
||||||
|
ARGUMENTOS = {
|
||||||
|
"buscar_fichero": "README.md",
|
||||||
|
"buscar_carpeta": "config",
|
||||||
|
"grep_recursivo": "JARVIS",
|
||||||
|
"leer_fichero": "README.md", # un NOMBRE, que es lo que se dice por voz
|
||||||
|
"abrir_carpeta": RAIZ,
|
||||||
|
"tamano_carpeta": os.path.join(RAIZ, "config"),
|
||||||
|
"buscar_youtube": "musica",
|
||||||
|
"buscar_wikipedia": "madrid",
|
||||||
|
"buscar_github": "newelle",
|
||||||
|
"traducir": "hola",
|
||||||
|
"buscar_web": "que hora es",
|
||||||
|
"matar_proceso": "proceso_que_no_existe_jarvis",
|
||||||
|
"ping": "127.0.0.1",
|
||||||
|
}
|
||||||
|
POR_DEFECTO = "prueba"
|
||||||
|
|
||||||
|
# Lo que abre o MUEVE ventanas. ventanas.sh reordena el escritorio del usuario:
|
||||||
|
# ejecutarlo en un repaso automatico le cambia las ventanas de sitio sin avisar.
|
||||||
|
VENTANA = re.compile(r"\b(firefox|xdg-open|gnome-terminal|nautilus|vlc|mpv|eog|"
|
||||||
|
r"gedit|gnome-text-editor|totem|ventanas\.sh|xdotool|wmctrl)\b")
|
||||||
|
|
||||||
|
|
||||||
|
def carga():
|
||||||
|
with open(CATALOGO, encoding="utf-8") as f:
|
||||||
|
d = json.load(f)
|
||||||
|
return d.get("acciones", d if isinstance(d, list) else [])
|
||||||
|
|
||||||
|
|
||||||
|
def prefijo_host():
|
||||||
|
"""Las acciones llevan host:true y en uso salen del sandbox. Aqui ya
|
||||||
|
estamos fuera, asi que no hace falta prefijo."""
|
||||||
|
return []
|
||||||
|
|
||||||
|
|
||||||
|
def ejecuta(accion, argumento, tope=25):
|
||||||
|
import shlex
|
||||||
|
import urllib.parse
|
||||||
|
|
||||||
|
comando = accion.get("comando") or ""
|
||||||
|
comando = comando.replace("{argumento}", shlex.quote(argumento))
|
||||||
|
comando = comando.replace("{argumento_url}",
|
||||||
|
shlex.quote(urllib.parse.quote_plus(argumento)))
|
||||||
|
t0 = time.monotonic()
|
||||||
|
try:
|
||||||
|
r = subprocess.run(["bash", "-lc", comando], capture_output=True,
|
||||||
|
text=True, errors="replace", timeout=tope)
|
||||||
|
salida = (r.stdout or r.stderr or "").strip()
|
||||||
|
return r.returncode, salida, time.monotonic() - t0
|
||||||
|
except subprocess.TimeoutExpired:
|
||||||
|
return -1, f"(no termino en {tope}s)", time.monotonic() - t0
|
||||||
|
except OSError as e:
|
||||||
|
return -2, f"(no se pudo ejecutar: {e})", time.monotonic() - t0
|
||||||
|
|
||||||
|
|
||||||
|
def programa_existe(comando):
|
||||||
|
"""El primer ejecutable de la orden, para las que abren o mueven ventanas.
|
||||||
|
|
||||||
|
Algunos son ordenes del PATH (firefox) y otros son scripts nuestros con
|
||||||
|
ruta completa (config/ventanas.sh): `command -v` solo sirve para los
|
||||||
|
primeros, y con los segundos hay que mirar el fichero.
|
||||||
|
"""
|
||||||
|
m = VENTANA.search(comando)
|
||||||
|
if not m:
|
||||||
|
return None
|
||||||
|
nombre = m.group(1)
|
||||||
|
if nombre.endswith(".sh"):
|
||||||
|
# sacar la ruta entera tal como aparece en el comando
|
||||||
|
for trozo in comando.split():
|
||||||
|
if trozo.endswith(nombre):
|
||||||
|
ruta = os.path.expandvars(os.path.expanduser(trozo))
|
||||||
|
return os.access(ruta, os.X_OK)
|
||||||
|
return False
|
||||||
|
return subprocess.run(["bash", "-lc", f"command -v {nombre}"],
|
||||||
|
capture_output=True).returncode == 0
|
||||||
|
|
||||||
|
|
||||||
|
def main():
|
||||||
|
p = argparse.ArgumentParser()
|
||||||
|
p.add_argument("--abrir", action="store_true",
|
||||||
|
help="ejecutar tambien las que abren ventanas")
|
||||||
|
p.add_argument("--grupo")
|
||||||
|
p.add_argument("--json")
|
||||||
|
p.add_argument("--tope", type=int, default=25)
|
||||||
|
args = p.parse_args()
|
||||||
|
|
||||||
|
acciones = carga()
|
||||||
|
if args.grupo:
|
||||||
|
acciones = [a for a in acciones if a.get("grupo") == args.grupo]
|
||||||
|
|
||||||
|
resultados = []
|
||||||
|
print(f" repasando {len(acciones)} acciones"
|
||||||
|
f"{' del grupo ' + args.grupo if args.grupo else ''}\n", flush=True)
|
||||||
|
|
||||||
|
for a in acciones:
|
||||||
|
ident = a.get("id", "?")
|
||||||
|
comando = a.get("comando") or ""
|
||||||
|
arg = ARGUMENTOS.get(ident, POR_DEFECTO if a.get("captura") else "")
|
||||||
|
|
||||||
|
if not comando:
|
||||||
|
estado, detalle = "solo habla", a.get("acuse", "")[:50]
|
||||||
|
elif a.get("confirmar") or "sudo" in comando:
|
||||||
|
# no se aprueban solas: en uso las aprueba una persona
|
||||||
|
estado, detalle = "saltada", "destructiva o con root"
|
||||||
|
elif VENTANA.search(comando) and not args.abrir:
|
||||||
|
hay = programa_existe(comando)
|
||||||
|
estado = "programa ok" if hay else "FALTA PROGRAMA"
|
||||||
|
detalle = VENTANA.search(comando).group(1)
|
||||||
|
else:
|
||||||
|
codigo, salida, tardo = ejecuta(a, arg, args.tope)
|
||||||
|
una_linea = " ".join(salida.split())[:70]
|
||||||
|
if codigo == 0:
|
||||||
|
estado = "ok" if salida else "ok (sin salida)"
|
||||||
|
else:
|
||||||
|
estado = f"FALLO ({codigo})"
|
||||||
|
detalle = f"{tardo:4.1f}s {una_linea}"
|
||||||
|
|
||||||
|
resultados.append({"id": ident, "grupo": a.get("grupo"),
|
||||||
|
"estado": estado, "detalle": detalle})
|
||||||
|
marca = "!" if "FALLO" in estado or "FALTA" in estado else " "
|
||||||
|
print(f" {marca} {ident:26s} {estado:16s} {detalle}", flush=True)
|
||||||
|
|
||||||
|
print()
|
||||||
|
from collections import Counter
|
||||||
|
c = Counter(r["estado"].split(" (")[0].split(" ")[0] for r in resultados)
|
||||||
|
for k, v in c.most_common():
|
||||||
|
print(f" {v:3d} {k}")
|
||||||
|
malas = [r for r in resultados if "FALLO" in r["estado"] or "FALTA" in r["estado"]]
|
||||||
|
print(f"\n {len(resultados) - len(malas)} de {len(resultados)} responden bien")
|
||||||
|
if malas:
|
||||||
|
print(" fallan: " + ", ".join(r["id"] for r in malas))
|
||||||
|
|
||||||
|
if args.json:
|
||||||
|
with open(args.json, "w", encoding="utf-8") as f:
|
||||||
|
json.dump(resultados, f, ensure_ascii=False, indent=2)
|
||||||
|
return 1 if malas else 0
|
||||||
|
|
||||||
|
|
||||||
|
if __name__ == "__main__":
|
||||||
|
sys.exit(main())
|
||||||
81
config/set_backend.py
Normal file
81
config/set_backend.py
Normal file
|
|
@ -0,0 +1,81 @@
|
||||||
|
#!/usr/bin/env python3
|
||||||
|
"""Pone el cerebro en Ollama sobre GPU y mata el razonamiento.
|
||||||
|
|
||||||
|
Se ejecuta DENTRO del flatpak, con la app CERRADA (si no, al salir puede
|
||||||
|
reescribir los ajustes con lo que tenia en memoria):
|
||||||
|
|
||||||
|
flatpak run --command=python3 io.github.qwersyk.Newelle//master \
|
||||||
|
~/COFRE/CODERS/JARVIS/config/set_backend.py
|
||||||
|
|
||||||
|
Por que Ollama y no el llamacpp interno: el llama.cpp que empaqueta el
|
||||||
|
flatpak es el prebuilt de CPU, sin CUDA, asi que el modelo corria entero
|
||||||
|
en procesador. Ollama ya esta en GPU. Los dos son locales igual.
|
||||||
|
|
||||||
|
Medido el 10 ago 2026 con qwen3.5:4b, misma pregunta:
|
||||||
|
|
||||||
|
think=true 41.2 s 749 tokens (casi todos de monologo interno)
|
||||||
|
think=false 2.5 s 44 tokens
|
||||||
|
|
||||||
|
De paso deja sana la ruta de llamacpp por si se vuelve a ella: el mismo
|
||||||
|
razonamiento se apaga alli con --reasoning-budget 0, y el contexto por
|
||||||
|
defecto (0 = el del modelo) abria 262144 por slot, unos 10 GB de RAM.
|
||||||
|
"""
|
||||||
|
import json
|
||||||
|
import sys
|
||||||
|
|
||||||
|
from gi.repository import Gio
|
||||||
|
|
||||||
|
SCHEMA = "io.github.qwersyk.Newelle"
|
||||||
|
MODELO = "qwen3.5:4b"
|
||||||
|
|
||||||
|
AJUSTES_OLLAMA = {
|
||||||
|
"endpoint": "http://localhost:11434",
|
||||||
|
"model": MODELO,
|
||||||
|
"custom_model": False,
|
||||||
|
"thinking": False, # lo que baja de 41 s a 2.5 s
|
||||||
|
"native_tool_calling": True,
|
||||||
|
"serve": False, # el servicio del sistema ya esta levantado
|
||||||
|
}
|
||||||
|
|
||||||
|
AJUSTES_LLAMACPP = {
|
||||||
|
"custom_args": "--reasoning-budget 0",
|
||||||
|
"ctx": 8192,
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
def main():
|
||||||
|
settings = Gio.Settings.new(SCHEMA)
|
||||||
|
|
||||||
|
try:
|
||||||
|
llm = json.loads(settings.get_string("llm-settings") or "{}")
|
||||||
|
except json.JSONDecodeError:
|
||||||
|
llm = {}
|
||||||
|
|
||||||
|
# merge, no reemplazo: ahi viven los ajustes de todos los proveedores
|
||||||
|
llm.setdefault("ollama", {}).update(AJUSTES_OLLAMA)
|
||||||
|
llm.setdefault("llamacpp", {}).update(AJUSTES_LLAMACPP)
|
||||||
|
|
||||||
|
settings.set_string("llm-settings", json.dumps(llm))
|
||||||
|
settings.set_string("language-model", "ollama")
|
||||||
|
Gio.Settings.sync()
|
||||||
|
|
||||||
|
# releer de gsettings, no fiarse de lo que acabamos de escribir
|
||||||
|
guardado = json.loads(settings.get_string("llm-settings"))
|
||||||
|
motor = settings.get_string("language-model")
|
||||||
|
ollama = guardado.get("ollama", {})
|
||||||
|
|
||||||
|
print(f"language-model: {motor}")
|
||||||
|
print(f"modelo: {ollama.get('model')}")
|
||||||
|
print(f"thinking: {ollama.get('thinking')}")
|
||||||
|
print(f"llamacpp: {guardado.get('llamacpp', {}).get('custom_args')} "
|
||||||
|
f"· ctx {guardado.get('llamacpp', {}).get('ctx')}")
|
||||||
|
|
||||||
|
ok = (motor == "ollama"
|
||||||
|
and ollama.get("model") == MODELO
|
||||||
|
and ollama.get("thinking") is False)
|
||||||
|
print("verificado" if ok else "FALLO: no quedo como se pidio")
|
||||||
|
return 0 if ok else 1
|
||||||
|
|
||||||
|
|
||||||
|
if __name__ == "__main__":
|
||||||
|
sys.exit(main())
|
||||||
100
config/set_castellano.py
Normal file
100
config/set_castellano.py
Normal file
|
|
@ -0,0 +1,100 @@
|
||||||
|
#!/usr/bin/env python3
|
||||||
|
"""Pasa JARVIS a castellano: voz, idioma y personalidad.
|
||||||
|
|
||||||
|
flatpak run --command=python3 io.github.qwersyk.Newelle//master \
|
||||||
|
~/COFRE/CODERS/JARVIS/config/set_castellano.py
|
||||||
|
|
||||||
|
La voz es em_alex, la mas grave de las dos masculinas en español que trae
|
||||||
|
Kokoro. Medido con las muestras de comparar_voces_es.py:
|
||||||
|
|
||||||
|
em_alex 129 Hz
|
||||||
|
em_alex grave 117 Hz <- elegida
|
||||||
|
em_santa 140 Hz
|
||||||
|
em_santa grave 132 Hz
|
||||||
|
|
||||||
|
El descenso de tono no va aqui sino en la cadena de audio (tts.py), porque se
|
||||||
|
aplica a la reproduccion y no a la seleccion de voz. Se ajusta con
|
||||||
|
JARVIS_TTS_GRAVEDAD.
|
||||||
|
|
||||||
|
Sustituye la personalidad inglesa en vez de añadir otra: dos personalidades
|
||||||
|
activas se pisan y el modelo acaba mezclando idiomas.
|
||||||
|
"""
|
||||||
|
import json
|
||||||
|
import sys
|
||||||
|
|
||||||
|
from gi.repository import Gio
|
||||||
|
|
||||||
|
SCHEMA = "io.github.qwersyk.Newelle"
|
||||||
|
VOZ = "em_alex"
|
||||||
|
CLAVE = "jarvis_persona"
|
||||||
|
|
||||||
|
TEXTO = """Eres JARVIS, un asistente de voz que funciona entero en esta maquina.
|
||||||
|
|
||||||
|
Como hablas:
|
||||||
|
- En castellano, siempre. Registro sobrio y contenido, sin efusividad.
|
||||||
|
- Trata al usuario de usted y llamale SIEMPRE "señor". En la primera
|
||||||
|
frase de cada respuesta, sin excepcion.
|
||||||
|
- Se breve: una o dos frases salvo que te pidan detalle. Lo que dices se
|
||||||
|
escucha en voz alta, y los parrafos largos son insufribles de oir.
|
||||||
|
- No anuncies lo que vas a hacer. Hazlo y di como ha quedado.
|
||||||
|
- Ironia seca de vez en cuando. Nunca servil, nunca efusivo.
|
||||||
|
|
||||||
|
Que dices:
|
||||||
|
- Tienes acceso real a esta maquina. Antes que suponer, comprueba: si te
|
||||||
|
preguntan por el disco, la memoria, los procesos o la grafica, ejecuta el
|
||||||
|
comando y responde con la cifra de verdad.
|
||||||
|
- Di los numeros redondeados y en palabras: "quedan 846 gigabytes", no
|
||||||
|
"846.3 GiB disponibles en /dev/nvme0n1p2".
|
||||||
|
- Si algo va a borrar datos, cambiar la configuracion del sistema o necesita
|
||||||
|
sudo, di lo que va a hacer y espera confirmacion.
|
||||||
|
- Si no lo sabes, dilo en una frase. No especules.
|
||||||
|
- Ejemplos del tono: "Enseguida, señor." / "Quedan 774 gigabytes, señor." /
|
||||||
|
"No he podido, señor: el disco esta desmontado."
|
||||||
|
- Si ves algo raro en la maquina, mencionalo aunque no te pregunten."""
|
||||||
|
|
||||||
|
ENTRADA = {
|
||||||
|
"key": CLAVE,
|
||||||
|
"text": TEXTO,
|
||||||
|
"title": "JARVIS",
|
||||||
|
"description": ("Castellano, trata de señor, registro sobrio, respuestas "
|
||||||
|
"breves para voz, comprueba en vez de suponer"),
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
def main():
|
||||||
|
settings = Gio.Settings.new(SCHEMA)
|
||||||
|
|
||||||
|
# voz
|
||||||
|
try:
|
||||||
|
voces = json.loads(settings.get_string("tts-voice") or "{}")
|
||||||
|
except json.JSONDecodeError:
|
||||||
|
voces = {}
|
||||||
|
voces.setdefault("kokoro", {})["voice"] = VOZ
|
||||||
|
settings.set_string("tts-voice", json.dumps(voces))
|
||||||
|
|
||||||
|
# personalidad, sustituyendo la que hubiera con la misma clave
|
||||||
|
try:
|
||||||
|
prompts = json.loads(settings.get_string("user-custom-prompts") or "[]")
|
||||||
|
except json.JSONDecodeError:
|
||||||
|
prompts = []
|
||||||
|
prompts = [p for p in prompts if p.get("key") != CLAVE]
|
||||||
|
prompts.append(ENTRADA)
|
||||||
|
settings.set_string("user-custom-prompts", json.dumps(prompts))
|
||||||
|
|
||||||
|
Gio.Settings.sync()
|
||||||
|
|
||||||
|
# releer de gsettings, no fiarse de lo que acabamos de escribir
|
||||||
|
voz = json.loads(settings.get_string("tts-voice")).get("kokoro", {}).get("voice")
|
||||||
|
guardados = json.loads(settings.get_string("user-custom-prompts"))
|
||||||
|
entrada = next((p for p in guardados if p.get("key") == CLAVE), None)
|
||||||
|
|
||||||
|
print(f"voz: {voz}")
|
||||||
|
print(f"personalidad: {'castellano' if entrada and 'castellano' in entrada['text'] else '?'}")
|
||||||
|
|
||||||
|
ok = voz == VOZ and entrada is not None and entrada["text"] == TEXTO
|
||||||
|
print("verificado" if ok else "FALLO: no quedo como se pidio")
|
||||||
|
return 0 if ok else 1
|
||||||
|
|
||||||
|
|
||||||
|
if __name__ == "__main__":
|
||||||
|
sys.exit(main())
|
||||||
137
config/set_persona.py
Normal file
137
config/set_persona.py
Normal file
|
|
@ -0,0 +1,137 @@
|
||||||
|
#!/usr/bin/env python3
|
||||||
|
"""Registra la personalidad de JARVIS, con lo que sabe hacer incluido.
|
||||||
|
|
||||||
|
flatpak run --command=python3 io.github.qwersyk.Newelle//master \
|
||||||
|
~/COFRE/CODERS/JARVIS/config/set_persona.py
|
||||||
|
|
||||||
|
Por que asi y no con `gsettings` desde fuera: gsettings devuelve los valores
|
||||||
|
con el escapado de GVariant, y este prompt lleva saltos de linea y comillas,
|
||||||
|
asi que releerlo como JSON desde bash falla. Gio maneja los tipos de verdad.
|
||||||
|
|
||||||
|
## Por que el prompt lleva la lista de capacidades
|
||||||
|
|
||||||
|
Hasta ahora no la llevaba, y el efecto era exactamente el que describia el
|
||||||
|
usuario: "duda de lo que puede hacer, no tiene claras sus capacidades". El
|
||||||
|
catalogo tiene 150 ordenes preparadas, pero el modelo no las veia por ningun
|
||||||
|
lado: solo leia "tienes acceso real a esta maquina" y, siendo un 4B, ante la
|
||||||
|
duda decia que no podia. En el registro de frases sin entender hay una
|
||||||
|
conversacion entera del usuario discutiendo con el:
|
||||||
|
|
||||||
|
"si que puedes reproducir archivos multimedia del sistema"
|
||||||
|
"En acciones no tienes esta opcion de 'fine'"
|
||||||
|
"Me deberias poder"
|
||||||
|
|
||||||
|
La lista se genera DESDE el catalogo, agrupada, para que no se quede vieja
|
||||||
|
cuando se añadan acciones. No se listan las 150 una por una: son demasiadas
|
||||||
|
para el contexto de un 4B y lo unico que hace falta es que sepa por donde va.
|
||||||
|
"""
|
||||||
|
import json
|
||||||
|
import os
|
||||||
|
import sys
|
||||||
|
|
||||||
|
from gi.repository import Gio
|
||||||
|
|
||||||
|
SCHEMA = "io.github.qwersyk.Newelle"
|
||||||
|
KEY = "user-custom-prompts"
|
||||||
|
CLAVE = "jarvis_persona"
|
||||||
|
|
||||||
|
RAIZ = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
|
||||||
|
CATALOGO = os.path.join(RAIZ, "newelle", "data", "acciones", "acciones.json")
|
||||||
|
|
||||||
|
# Como se resume cada grupo. Escrito a mano porque el resumen bueno no sale de
|
||||||
|
# juntar ids: sale de decir en una linea de que va el grupo.
|
||||||
|
RESUMEN = {
|
||||||
|
"sistema": "disco, memoria, temperatura, procesos, red, wifi, bateria, "
|
||||||
|
"brillo, volumen, pantallas, capturas, abrir terminal y poner videos",
|
||||||
|
"ficheros": "buscar ficheros por nombre, buscar texto dentro de ellos, "
|
||||||
|
"leerlos, abrir carpetas y ver cuanto ocupan",
|
||||||
|
"ventanas": "mover ventanas entre pantallas, colocarlas en mitades o cuartos, "
|
||||||
|
"maximizar y pasarlas de escritorio",
|
||||||
|
"firefox": "abrir webs y buscar en internet, YouTube, Wikipedia, GitHub, "
|
||||||
|
"mapas y traductor",
|
||||||
|
"pentest": "escanear la red, mirar puertos, resolver dominios y whois",
|
||||||
|
"oasis": "estado de Oasis: pubs, conexiones y tamaño",
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
def capacidades() -> str:
|
||||||
|
try:
|
||||||
|
with open(CATALOGO, encoding="utf-8") as f:
|
||||||
|
acc = json.load(f)["acciones"]
|
||||||
|
except Exception:
|
||||||
|
return ""
|
||||||
|
grupos = {}
|
||||||
|
for a in acc:
|
||||||
|
grupos.setdefault(a.get("grupo", "otras"), []).append(a)
|
||||||
|
lineas = []
|
||||||
|
for g, items in sorted(grupos.items(), key=lambda x: -len(x[1])):
|
||||||
|
texto = RESUMEN.get(g)
|
||||||
|
if texto:
|
||||||
|
lineas.append(f"- {texto} ({len(items)} ordenes)")
|
||||||
|
return "\n".join(lineas)
|
||||||
|
|
||||||
|
|
||||||
|
TEXTO = """Eres JARVIS, un asistente de voz que funciona entero en esta maquina.
|
||||||
|
|
||||||
|
Como hablas:
|
||||||
|
- En castellano, siempre. Registro sobrio y contenido, sin efusividad.
|
||||||
|
- Trata al usuario de usted y llamale SIEMPRE "señor". En la primera
|
||||||
|
frase de cada respuesta, sin excepcion.
|
||||||
|
- Se breve: una o dos frases salvo que te pidan detalle. Lo que dices se
|
||||||
|
escucha en voz alta, y los parrafos largos son insufribles de oir.
|
||||||
|
- No anuncies lo que vas a hacer. Hazlo y di como ha quedado.
|
||||||
|
- Ironia seca de vez en cuando. Nunca servil, nunca efusivo.
|
||||||
|
|
||||||
|
LO QUE SABES HACER, y lo haces de verdad:
|
||||||
|
{capacidades}
|
||||||
|
|
||||||
|
Esas ordenes se disparan SOLAS en cuanto el usuario las dice: cuando te llega
|
||||||
|
una peticion de esa lista, lo mas probable es que ya se haya ejecutado. No
|
||||||
|
digas que no puedes hacerlas.
|
||||||
|
|
||||||
|
Y para todo lo demas tienes una TERMINAL REAL en esta maquina, fuera de
|
||||||
|
cualquier contenedor: ves todos los ficheros del usuario y puedes ejecutar
|
||||||
|
cualquier programa instalado. Si te piden algo que no esta en la lista,
|
||||||
|
ejecutalo con la herramienta de comandos en vez de decir que no sabes.
|
||||||
|
|
||||||
|
NUNCA digas que estas en un contenedor, en un entorno aislado o en una
|
||||||
|
maquina virtual, ni que no tienes permisos o acceso al sistema. Lo tienes.
|
||||||
|
Si un comando falla, di QUE fallo y por que, no que no puedes.
|
||||||
|
|
||||||
|
Si no entiendes una orden, no te disculpes en tres frases: di en una que no la
|
||||||
|
has cogido y, si te suena a algo de la lista, sugiere como pedirlo.
|
||||||
|
|
||||||
|
Que dices:
|
||||||
|
- Antes que suponer, comprueba: si te preguntan por el disco, la memoria, los
|
||||||
|
procesos o la grafica, ejecuta el comando y responde con la cifra de verdad.
|
||||||
|
- Di los numeros redondeados y en palabras: "quedan 846 gigabytes", no
|
||||||
|
"846.3 GiB disponibles en /dev/nvme0n1p2".
|
||||||
|
- Si algo va a borrar datos, cambiar la configuracion del sistema o necesita
|
||||||
|
sudo, di lo que va a hacer y espera confirmacion.
|
||||||
|
- Si no lo sabes, dilo en una frase. No especules.
|
||||||
|
- Ejemplos del tono: "Enseguida, señor." / "Quedan 774 gigabytes, señor." /
|
||||||
|
"No he podido, señor: el disco esta desmontado."
|
||||||
|
- Si ves algo raro en la maquina, mencionalo aunque no te pregunten."""
|
||||||
|
|
||||||
|
|
||||||
|
def main():
|
||||||
|
texto = TEXTO.format(capacidades=capacidades() or "- (catalogo no disponible)")
|
||||||
|
settings = Gio.Settings.new(SCHEMA)
|
||||||
|
try:
|
||||||
|
prompts = json.loads(settings.get_string(KEY) or "[]")
|
||||||
|
except json.JSONDecodeError:
|
||||||
|
prompts = []
|
||||||
|
prompts = [p for p in prompts if p.get("key") != CLAVE]
|
||||||
|
prompts.append({"key": CLAVE, "title": "JARVIS",
|
||||||
|
"description": "Personalidad de JARVIS, con la lista de lo "
|
||||||
|
"que sabe hacer generada desde el catalogo",
|
||||||
|
"text": texto,
|
||||||
|
"editable": True, "show_in_settings": True})
|
||||||
|
settings.set_string(KEY, json.dumps(prompts))
|
||||||
|
print(f"personalidad registrada: {len(texto)} caracteres, "
|
||||||
|
f"{len(capacidades().splitlines())} grupos de capacidades")
|
||||||
|
return 0
|
||||||
|
|
||||||
|
|
||||||
|
if __name__ == "__main__":
|
||||||
|
sys.exit(main())
|
||||||
60
config/set_ruido.py
Normal file
60
config/set_ruido.py
Normal file
|
|
@ -0,0 +1,60 @@
|
||||||
|
#!/usr/bin/env python3
|
||||||
|
"""Endurece la escucha para que no se dispare con ruido de fuera.
|
||||||
|
|
||||||
|
flatpak run --command=python3 io.github.qwersyk.Newelle//master \
|
||||||
|
~/COFRE/CODERS/JARVIS/config/set_ruido.py [--suave]
|
||||||
|
|
||||||
|
NO es reconocimiento de hablante: Newelle no distingue quien habla, no hay
|
||||||
|
nada de eso en el codigo. Esto solo sube el liston de que se considera voz.
|
||||||
|
Para que responda unicamente a una persona haria falta un modelo de huella
|
||||||
|
vocal (ECAPA, Resemblyzer) delante del STT, que es otro proyecto.
|
||||||
|
|
||||||
|
Las tres capas, de menos a mas efectiva:
|
||||||
|
|
||||||
|
1. la palabra clave, que ya filtra casi todo
|
||||||
|
2. estos umbrales
|
||||||
|
3. supresion de ruido en PipeWire (RNNoise), antes de que el audio llegue
|
||||||
|
a la app; esa vale para todo el sistema y no cuesta CPU a Newelle
|
||||||
|
|
||||||
|
Valores por defecto de Newelle: energia 300, VAD 1.
|
||||||
|
"""
|
||||||
|
import sys
|
||||||
|
|
||||||
|
from gi.repository import Gio
|
||||||
|
|
||||||
|
SCHEMA = "io.github.qwersyk.Newelle"
|
||||||
|
|
||||||
|
# vad-aggressiveness va de 0 a 3: cuanto descarta lo que no suena a voz.
|
||||||
|
DURO = {
|
||||||
|
"wakeword-energy-threshold": 800, # por debajo de esto ni escucha
|
||||||
|
"wakeword-vad-aggressiveness": 3,
|
||||||
|
}
|
||||||
|
SUAVE = {
|
||||||
|
"wakeword-energy-threshold": 500,
|
||||||
|
"wakeword-vad-aggressiveness": 2,
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
def main():
|
||||||
|
perfil = SUAVE if "--suave" in sys.argv else DURO
|
||||||
|
settings = Gio.Settings.new(SCHEMA)
|
||||||
|
|
||||||
|
print("antes:")
|
||||||
|
for clave in perfil:
|
||||||
|
print(f" {clave} = {settings.get_int(clave)}")
|
||||||
|
|
||||||
|
for clave, valor in perfil.items():
|
||||||
|
settings.set_int(clave, valor)
|
||||||
|
Gio.Settings.sync()
|
||||||
|
|
||||||
|
print("despues:")
|
||||||
|
for clave in perfil:
|
||||||
|
print(f" {clave} = {settings.get_int(clave)}")
|
||||||
|
|
||||||
|
ok = all(settings.get_int(c) == v for c, v in perfil.items())
|
||||||
|
print("verificado" if ok else "FALLO: no quedo como se pidio")
|
||||||
|
return 0 if ok else 1
|
||||||
|
|
||||||
|
|
||||||
|
if __name__ == "__main__":
|
||||||
|
sys.exit(main())
|
||||||
74
config/set_voz_piper.py
Normal file
74
config/set_voz_piper.py
Normal file
|
|
@ -0,0 +1,74 @@
|
||||||
|
#!/usr/bin/env python3
|
||||||
|
"""Pone la voz de Piper: castellano de España, grave.
|
||||||
|
|
||||||
|
flatpak run --command=python3 io.github.qwersyk.Newelle//master \
|
||||||
|
~/COFRE/CODERS/JARVIS/config/set_voz_piper.py
|
||||||
|
|
||||||
|
Por que no Kokoro: no tiene ni una voz de España. Sus dos masculinas en
|
||||||
|
español, em_alex y em_santa, suenan latinoamericanas. Piper si las tiene, es
|
||||||
|
libre (MIT, voces con licencias abiertas) y corre local.
|
||||||
|
|
||||||
|
Medido con la misma frase:
|
||||||
|
|
||||||
|
em_alex (Kokoro, latino) 129 Hz
|
||||||
|
es_ES-carlfm-x_low 118 Hz calidad baja, 16 kHz
|
||||||
|
es_ES-sharvard-medium 127 Hz
|
||||||
|
es_ES-davefx-medium 128 Hz
|
||||||
|
es_ES-sharvard-medium + tono 106 Hz <- elegida
|
||||||
|
|
||||||
|
106 Hz cae de lleno en el rango de voz masculina grave (85-110). Se llega ahi
|
||||||
|
con rubberband en el envoltorio, no con la cadena de la app: alli el descenso
|
||||||
|
usa asetrate, que depende de la frecuencia de muestreo y esta calculado para
|
||||||
|
los 24 kHz de Kokoro, no para los 22050 de Piper.
|
||||||
|
|
||||||
|
Se apaga por tanto la bajada de tono de la app, para no aplicarla dos veces.
|
||||||
|
El resto del tratamiento (paso alto, ecualizador, compresor, eco) se queda:
|
||||||
|
es independiente de la frecuencia y es lo que da el aire de "voz en la sala".
|
||||||
|
"""
|
||||||
|
import json
|
||||||
|
import os
|
||||||
|
import sys
|
||||||
|
|
||||||
|
from gi.repository import Gio
|
||||||
|
|
||||||
|
SCHEMA = "io.github.qwersyk.Newelle"
|
||||||
|
ENVOLTORIO = os.path.expanduser(
|
||||||
|
"~/COFRE/CODERS/JARVIS/config/jarvis-piper.sh")
|
||||||
|
|
||||||
|
|
||||||
|
def main():
|
||||||
|
if not os.path.exists(ENVOLTORIO):
|
||||||
|
print(f"FALLO: no esta {ENVOLTORIO}")
|
||||||
|
return 1
|
||||||
|
|
||||||
|
settings = Gio.Settings.new(SCHEMA)
|
||||||
|
|
||||||
|
try:
|
||||||
|
voces = json.loads(settings.get_string("tts-voice") or "{}")
|
||||||
|
except json.JSONDecodeError:
|
||||||
|
voces = {}
|
||||||
|
|
||||||
|
# {0} es el fichero y {1} el texto; el handler los entrecomilla, asi que
|
||||||
|
# aqui van sin comillas alrededor
|
||||||
|
voces["custom_command"] = {"command": f"{ENVOLTORIO} {{0}} {{1}}"}
|
||||||
|
settings.set_string("tts-voice", json.dumps(voces))
|
||||||
|
settings.set_string("tts", "custom_command")
|
||||||
|
Gio.Settings.sync()
|
||||||
|
|
||||||
|
motor = settings.get_string("tts")
|
||||||
|
orden = json.loads(settings.get_string("tts-voice")).get(
|
||||||
|
"custom_command", {}).get("command", "")
|
||||||
|
|
||||||
|
print(f"motor de voz: {motor}")
|
||||||
|
print(f"orden: {orden}")
|
||||||
|
|
||||||
|
ok = motor == "custom_command" and ENVOLTORIO in orden
|
||||||
|
print("verificado" if ok else "FALLO: no quedo como se pidio")
|
||||||
|
if ok:
|
||||||
|
print("\nrecuerda apagar la bajada de tono de la app, que ya la hace el envoltorio:")
|
||||||
|
print(" flatpak override --user --env=JARVIS_TTS_GRAVEDAD=1.0 io.github.qwersyk.Newelle")
|
||||||
|
return 0 if ok else 1
|
||||||
|
|
||||||
|
|
||||||
|
if __name__ == "__main__":
|
||||||
|
sys.exit(main())
|
||||||
290
config/ventanas.sh
Executable file
290
config/ventanas.sh
Executable file
|
|
@ -0,0 +1,290 @@
|
||||||
|
#!/usr/bin/env bash
|
||||||
|
# Mover ventanas y repartirlas por las pantallas. El motor de las acciones del
|
||||||
|
# grupo "ventanas": ellas solo llaman aqui con un verbo y un argumento.
|
||||||
|
#
|
||||||
|
# Por que un script del host y no un modulo dentro del flatpak: las acciones se
|
||||||
|
# ejecutan como comandos de shell, y toda la logica en Python obligaria a
|
||||||
|
# recompilar el flatpak por cada ajuste. Aqui se edita y ya esta, igual que los
|
||||||
|
# envoltorios de voz.
|
||||||
|
#
|
||||||
|
# Requiere X11 (en Wayland no hay forma de mover ventanas ajenas) y xdotool.
|
||||||
|
#
|
||||||
|
# ventanas.sh pantallas lista las pantallas
|
||||||
|
# ventanas.sh listar lista las ventanas movibles
|
||||||
|
# ventanas.sh mover <ventana> <pantalla> la manda a esa pantalla
|
||||||
|
# ventanas.sh zona <ventana> <zona> mitad izquierda, cuarto, centro...
|
||||||
|
# ventanas.sh escritorio <ventana> <n> la manda a ese escritorio virtual
|
||||||
|
# ventanas.sh maximiza <ventana> / restaura / minimiza
|
||||||
|
# ventanas.sh alias <pantalla> <nombre> le pone nombre a una salida
|
||||||
|
#
|
||||||
|
# <ventana> puede ser: parte del titulo o de la clase ("terminal", "firefox"),
|
||||||
|
# o "esta"/"activa" para la que tiene el foco.
|
||||||
|
# <pantalla> puede ser: un alias ("tele"), una salida ("HDMI-1"), un numero
|
||||||
|
# ("2") o una posicion ("derecha", "izquierda", "arriba", "abajo", "centro").
|
||||||
|
set -uo pipefail
|
||||||
|
|
||||||
|
RAIZ=$(cd -P "$(dirname "${BASH_SOURCE[0]:-$0}")/.." && pwd)
|
||||||
|
ALIAS_FICHERO=${JARVIS_ALIAS_PANTALLAS:-$HOME/.config/jarvis-pantallas.json}
|
||||||
|
|
||||||
|
hay_x11() { [ -n "${DISPLAY:-}" ] && command -v xdotool >/dev/null; }
|
||||||
|
hay_x11 || { echo "no hay X11 o falta xdotool"; exit 1; }
|
||||||
|
|
||||||
|
# ---------------------------------------------------------------- pantallas
|
||||||
|
|
||||||
|
# Una linea por pantalla: salida<TAB>x<TAB>y<TAB>ancho<TAB>alto<TAB>numero
|
||||||
|
#
|
||||||
|
# Se usa `xrandr --listmonitors`, que da la geometria ya resuelta (con el
|
||||||
|
# escalado aplicado); `--query` daria los modos, que no es lo que hace falta.
|
||||||
|
# El numero es el orden de izquierda a derecha, no el que diga xrandr: es lo
|
||||||
|
# que espera cualquiera que diga "la pantalla dos".
|
||||||
|
pantallas_crudas() {
|
||||||
|
xrandr --listmonitors 2>/dev/null | tail -n +2 | while read -r _ _ geo salida; do
|
||||||
|
# geo viene como 1920/344x1080/194+0+0
|
||||||
|
local an al x y
|
||||||
|
an=${geo%%/*}; geo=${geo#*x}
|
||||||
|
al=${geo%%/*}; geo=${geo#*+}
|
||||||
|
x=${geo%%+*}; y=${geo##*+}
|
||||||
|
printf '%s\t%s\t%s\t%s\t%s\n' "$salida" "$x" "$y" "$an" "$al"
|
||||||
|
done | sort -t$'\t' -k2 -n | awk -F'\t' '{printf "%s\t%s\t%s\t%s\t%s\t%d\n", $1,$2,$3,$4,$5,NR}'
|
||||||
|
}
|
||||||
|
|
||||||
|
alias_de() {
|
||||||
|
[ -f "$ALIAS_FICHERO" ] || { echo ""; return; }
|
||||||
|
python3 -c "
|
||||||
|
import json, sys
|
||||||
|
try:
|
||||||
|
print(json.load(open('$ALIAS_FICHERO')).get(sys.argv[1], ''))
|
||||||
|
except Exception:
|
||||||
|
print('')
|
||||||
|
" "$1" 2>/dev/null
|
||||||
|
}
|
||||||
|
|
||||||
|
# izquierda / derecha / arriba / abajo / centro, deducido de donde cae el
|
||||||
|
# centro de esa pantalla respecto al centro de todas.
|
||||||
|
posicion_de() {
|
||||||
|
local x=$1 an=$2 y=$3 al=$4
|
||||||
|
local n; n=$(pantallas_crudas | wc -l)
|
||||||
|
[ "$n" -le 1 ] && { echo "unica"; return; }
|
||||||
|
local minx maxx miny maxy
|
||||||
|
minx=$(pantallas_crudas | awk -F'\t' 'NR==1||$2<m{m=$2}END{print m+0}')
|
||||||
|
maxx=$(pantallas_crudas | awk -F'\t' '{v=$2+$4; if(v>m)m=v}END{print m+0}')
|
||||||
|
miny=$(pantallas_crudas | awk -F'\t' 'NR==1||$3<m{m=$3}END{print m+0}')
|
||||||
|
maxy=$(pantallas_crudas | awk -F'\t' '{v=$3+$5; if(v>m)m=v}END{print m+0}')
|
||||||
|
local cx=$(( x + an/2 )) cy=$(( y + al/2 ))
|
||||||
|
local mx=$(( (minx+maxx)/2 )) my=$(( (miny+maxy)/2 ))
|
||||||
|
local anchura=$(( maxx-minx )) altura=$(( maxy-miny ))
|
||||||
|
# el reparto manda por el eje donde hay mas separacion
|
||||||
|
if [ $(( anchura - altura )) -gt 0 ]; then
|
||||||
|
[ "$cx" -lt $(( mx - anchura/8 )) ] && { echo izquierda; return; }
|
||||||
|
[ "$cx" -gt $(( mx + anchura/8 )) ] && { echo derecha; return; }
|
||||||
|
else
|
||||||
|
[ "$cy" -lt $(( my - altura/8 )) ] && { echo arriba; return; }
|
||||||
|
[ "$cy" -gt $(( my + altura/8 )) ] && { echo abajo; return; }
|
||||||
|
fi
|
||||||
|
echo centro
|
||||||
|
}
|
||||||
|
|
||||||
|
listar_pantallas() {
|
||||||
|
local salida x y an al num pos ali
|
||||||
|
while IFS=$'\t' read -r salida x y an al num; do
|
||||||
|
pos=$(posicion_de "$x" "$an" "$y" "$al")
|
||||||
|
ali=$(alias_de "$salida")
|
||||||
|
printf '%s\t%s\t%s\t%s\t%s\t%s\t%s\t%s\n' \
|
||||||
|
"$num" "$salida" "${ali:--}" "$pos" "$x" "$y" "$an" "$al"
|
||||||
|
done < <(pantallas_crudas)
|
||||||
|
}
|
||||||
|
|
||||||
|
# Resuelve lo que se dice a una pantalla. Orden a proposito: primero lo que el
|
||||||
|
# usuario ha nombrado el mismo, que es lo mas especifico, y la posicion la
|
||||||
|
# ultima porque es la mas facil de confundir.
|
||||||
|
resuelve_pantalla() {
|
||||||
|
local q; q=$(echo "$1" | tr 'A-ZÁÉÍÓÚ' 'a-záéíóú')
|
||||||
|
local num salida ali pos x y an al
|
||||||
|
# 1. alias
|
||||||
|
while IFS=$'\t' read -r num salida ali pos x y an al; do
|
||||||
|
[ "$ali" != "-" ] && [ "$(echo "$ali" | tr 'A-Z' 'a-z')" = "$q" ] && {
|
||||||
|
printf '%s\t%s\t%s\t%s\t%s\n' "$salida" "$x" "$y" "$an" "$al"; return 0; }
|
||||||
|
done < <(listar_pantallas)
|
||||||
|
# 2. salida exacta o su prefijo (hdmi, dp)
|
||||||
|
while IFS=$'\t' read -r num salida ali pos x y an al; do
|
||||||
|
local s; s=$(echo "$salida" | tr 'A-Z' 'a-z')
|
||||||
|
[ "$s" = "$q" ] || [ "${s%%-*}" = "$q" ] && {
|
||||||
|
printf '%s\t%s\t%s\t%s\t%s\n' "$salida" "$x" "$y" "$an" "$al"; return 0; }
|
||||||
|
done < <(listar_pantallas)
|
||||||
|
# 3. numero, en cifra o en letra
|
||||||
|
local n=""
|
||||||
|
case "$q" in
|
||||||
|
1|una|uno|primera) n=1;; 2|dos|segunda) n=2;; 3|tres|tercera) n=3;; 4|cuatro|cuarta) n=4;;
|
||||||
|
esac
|
||||||
|
if [ -n "$n" ]; then
|
||||||
|
while IFS=$'\t' read -r num salida ali pos x y an al; do
|
||||||
|
[ "$num" = "$n" ] && { printf '%s\t%s\t%s\t%s\t%s\n' "$salida" "$x" "$y" "$an" "$al"; return 0; }
|
||||||
|
done < <(listar_pantallas)
|
||||||
|
fi
|
||||||
|
# 4. posicion
|
||||||
|
while IFS=$'\t' read -r num salida ali pos x y an al; do
|
||||||
|
[ "$pos" = "$q" ] && { printf '%s\t%s\t%s\t%s\t%s\n' "$salida" "$x" "$y" "$an" "$al"; return 0; }
|
||||||
|
done < <(listar_pantallas)
|
||||||
|
return 1
|
||||||
|
}
|
||||||
|
|
||||||
|
# ----------------------------------------------------------------- ventanas
|
||||||
|
|
||||||
|
# El area util de la pantalla que contiene un punto: hay que descontar barras
|
||||||
|
# y paneles, o las ventanas acaban debajo de la barra de GNOME.
|
||||||
|
area_util() {
|
||||||
|
local v; v=$(xprop -root _NET_WORKAREA 2>/dev/null | sed 's/.*= //' | tr -d ' ')
|
||||||
|
if [ -n "$v" ]; then
|
||||||
|
echo "$(echo "$v" | cut -d, -f1) $(echo "$v" | cut -d, -f2) $(echo "$v" | cut -d, -f3) $(echo "$v" | cut -d, -f4)"
|
||||||
|
else
|
||||||
|
set -- $(xdotool getdisplaygeometry); echo "0 0 $1 $2"
|
||||||
|
fi
|
||||||
|
}
|
||||||
|
|
||||||
|
# Se descartan las que no son ventanas de verdad: el guardian de mutter, el
|
||||||
|
# propio shell y las de 1x1 que usan algunos programas como buzon.
|
||||||
|
listar_ventanas() {
|
||||||
|
local w n cls x y an al
|
||||||
|
for w in $(xdotool search --onlyvisible --name "." 2>/dev/null); do
|
||||||
|
n=$(xdotool getwindowname "$w" 2>/dev/null) || continue
|
||||||
|
[ -z "$n" ] && continue
|
||||||
|
case "$n" in "mutter guard window"|"gnome-shell") continue;; esac
|
||||||
|
eval "$(xdotool getwindowgeometry --shell "$w" 2>/dev/null)" || continue
|
||||||
|
[ "${WIDTH:-0}" -lt 50 ] && continue
|
||||||
|
cls=$(xprop -id "$w" WM_CLASS 2>/dev/null | sed 's/.*, *//' | tr -d '"')
|
||||||
|
printf '%s\t%s\t%s\t%s\t%s\t%s\t%s\n' "$w" "$n" "${cls:--}" "$X" "$Y" "$WIDTH" "$HEIGHT"
|
||||||
|
done
|
||||||
|
}
|
||||||
|
|
||||||
|
# Devuelve el id, o varios si hay empate: quien llama decide si preguntar.
|
||||||
|
resuelve_ventana() {
|
||||||
|
local q; q=$(echo "$1" | tr 'A-ZÁÉÍÓÚ' 'a-záéíóú')
|
||||||
|
case "$q" in
|
||||||
|
esta|activa|"esta ventana"|"la activa"|"ventana activa")
|
||||||
|
xdotool getactivewindow 2>/dev/null; return;;
|
||||||
|
esac
|
||||||
|
listar_ventanas | awk -F'\t' -v q="$q" '
|
||||||
|
BEGIN{IGNORECASE=1}
|
||||||
|
{ t=tolower($2); c=tolower($3);
|
||||||
|
if (index(t,q) || index(c,q)) print $1"\t"$2 }'
|
||||||
|
}
|
||||||
|
|
||||||
|
geo_de() { eval "$(xdotool getwindowgeometry --shell "$1" 2>/dev/null)"; echo "$X $Y $WIDTH $HEIGHT"; }
|
||||||
|
|
||||||
|
# Maximizar NO se hace con `xdotool windowstate --add MAXIMIZED`: comprobado,
|
||||||
|
# en mutter no hace nada. Lo que funciona es activar la ventana y mandar el
|
||||||
|
# atajo del escritorio. Y una ventana maximizada IGNORA windowmove, asi que
|
||||||
|
# hay que desmaximizar antes de mover.
|
||||||
|
desmaximiza() { xdotool windowactivate "$1" 2>/dev/null; sleep 0.2; xdotool key super+Down 2>/dev/null; sleep 0.4; }
|
||||||
|
maximiza() { xdotool windowactivate "$1" 2>/dev/null; sleep 0.2; xdotool key super+Up 2>/dev/null; sleep 0.4; }
|
||||||
|
|
||||||
|
coloca() { # coloca <id> <x> <y> <ancho> <alto>
|
||||||
|
desmaximiza "$1"
|
||||||
|
xdotool windowsize "$1" "$4" "$5" 2>/dev/null
|
||||||
|
xdotool windowmove "$1" "$2" "$3" 2>/dev/null
|
||||||
|
sleep 0.3
|
||||||
|
}
|
||||||
|
|
||||||
|
# --------------------------------------------------------------------- api
|
||||||
|
|
||||||
|
# Imprime el id, o una frase que se pueda decir en voz alta. Nada de
|
||||||
|
# marcadores tipo NINGUNA/VARIAS: lo que salga de aqui puede acabar en el
|
||||||
|
# altavoz tal cual, asi que tiene que ser castellano.
|
||||||
|
una_ventana() {
|
||||||
|
local r; r=$(resuelve_ventana "$1")
|
||||||
|
local n; n=$(echo "$r" | grep -c . )
|
||||||
|
if [ "$n" -eq 0 ]; then
|
||||||
|
echo "No encuentro ninguna ventana que sea $1, señor."; return 1
|
||||||
|
fi
|
||||||
|
if [ "$n" -gt 1 ]; then
|
||||||
|
# Ambiguo: se enumeran y decide la persona. Elegir una al azar es lo
|
||||||
|
# peor que puede hacer algo que mueve ventanas ajenas.
|
||||||
|
printf 'Hay %s que encajan, señor: %s. Digame cual.\n' "$n" \
|
||||||
|
"$(echo "$r" | cut -f2 | head -4 | paste -sd'|' - | sed 's/|/; /g')"
|
||||||
|
return 2
|
||||||
|
fi
|
||||||
|
echo "$r" | cut -f1
|
||||||
|
}
|
||||||
|
|
||||||
|
case "${1:-}" in
|
||||||
|
pantallas)
|
||||||
|
listar_pantallas | while IFS=$'\t' read -r num salida ali pos x y an al; do
|
||||||
|
printf 'pantalla %s: %s%s, %s, %sx%s\n' "$num" "$salida" \
|
||||||
|
"$([ "$ali" != "-" ] && echo " ($ali)")" "$pos" "$an" "$al"
|
||||||
|
done
|
||||||
|
;;
|
||||||
|
|
||||||
|
listar)
|
||||||
|
listar_ventanas | while IFS=$'\t' read -r w n cls x y an al; do
|
||||||
|
printf '%s (%s) %sx%s en %s,%s\n' "$n" "$cls" "$an" "$al" "$x" "$y"
|
||||||
|
done
|
||||||
|
;;
|
||||||
|
|
||||||
|
alias)
|
||||||
|
salida=$(resuelve_pantalla "${2:-}" | cut -f1)
|
||||||
|
[ -n "$salida" ] || { echo "No se cual es esa pantalla, señor"; exit 1; }
|
||||||
|
python3 - "$ALIAS_FICHERO" "$salida" "${3:-}" <<'FIN'
|
||||||
|
import json, os, sys
|
||||||
|
fichero, salida, nombre = sys.argv[1], sys.argv[2], sys.argv[3]
|
||||||
|
os.makedirs(os.path.dirname(fichero), exist_ok=True)
|
||||||
|
try:
|
||||||
|
d = json.load(open(fichero))
|
||||||
|
except Exception:
|
||||||
|
d = {}
|
||||||
|
d[salida] = nombre
|
||||||
|
json.dump(d, open(fichero, "w"), ensure_ascii=False, indent=2)
|
||||||
|
print(f"{salida} se llama ahora {nombre}")
|
||||||
|
FIN
|
||||||
|
;;
|
||||||
|
|
||||||
|
mover)
|
||||||
|
w=$(una_ventana "${2:-}") || { echo "$w"; exit 1; }
|
||||||
|
destino=$(resuelve_pantalla "${3:-}") || { echo "No se cual es esa pantalla, señor"; exit 1; }
|
||||||
|
IFS=$'\t' read -r salida px py pan pal <<< "$destino"
|
||||||
|
read -r ax ay aan aal <<< "$(area_util)"
|
||||||
|
# se centra en la pantalla destino, a tres cuartos de su tamaño
|
||||||
|
an=$(( pan * 3 / 4 )); al=$(( pal * 3 / 4 ))
|
||||||
|
x=$(( px + (pan - an) / 2 )); y=$(( py + (pal - al) / 2 ))
|
||||||
|
[ "$y" -lt "$ay" ] && y=$ay
|
||||||
|
coloca "$w" "$x" "$y" "$an" "$al"
|
||||||
|
# "eDP-1" en voz alta se lee letra por letra: se dice el mote si lo tiene,
|
||||||
|
# y si no el numero, que es lo que entiende cualquiera.
|
||||||
|
comodo=$(listar_pantallas | awk -F'\t' -v s="$salida" '$2==s {print ($3!="-") ? $3 : "numero " $1}')
|
||||||
|
echo "Movida a la pantalla ${comodo:-$salida}"
|
||||||
|
;;
|
||||||
|
|
||||||
|
zona)
|
||||||
|
w=$(una_ventana "${2:-}") || { echo "$w"; exit 1; }
|
||||||
|
read -r ax ay aan aal <<< "$(area_util)"
|
||||||
|
m2=$(( aan / 2 )); h2=$(( aal / 2 ))
|
||||||
|
case "$(echo "${3:-}" | tr 'A-ZÁÉÍÓÚ' 'a-záéíóú')" in
|
||||||
|
izquierda|"mitad izquierda") coloca "$w" "$ax" "$ay" "$m2" "$aal"; echo "Ya la tiene a la izquierda";;
|
||||||
|
derecha|"mitad derecha") coloca "$w" $((ax+m2)) "$ay" "$m2" "$aal"; echo "Ya la tiene a la derecha";;
|
||||||
|
arriba) coloca "$w" "$ax" "$ay" "$aan" "$h2"; echo "Ya la tiene arriba";;
|
||||||
|
abajo) coloca "$w" "$ax" $((ay+h2)) "$aan" "$h2"; echo "Ya la tiene abajo";;
|
||||||
|
"arriba izquierda") coloca "$w" "$ax" "$ay" "$m2" "$h2"; echo "Colocada arriba a la izquierda";;
|
||||||
|
"arriba derecha") coloca "$w" $((ax+m2)) "$ay" "$m2" "$h2"; echo "Colocada arriba a la derecha";;
|
||||||
|
"abajo izquierda") coloca "$w" "$ax" $((ay+h2)) "$m2" "$h2"; echo "Colocada abajo a la izquierda";;
|
||||||
|
"abajo derecha") coloca "$w" $((ax+m2)) $((ay+h2)) "$m2" "$h2"; echo "Colocada abajo a la derecha";;
|
||||||
|
centro|centrada) coloca "$w" $((ax+aan/4)) $((ay+aal/4)) $((aan/2)) $((aal/2)); echo "Ya la tiene centrada";;
|
||||||
|
*) echo "No conozco esa zona, señor"; exit 1;;
|
||||||
|
esac
|
||||||
|
;;
|
||||||
|
|
||||||
|
maximiza) w=$(una_ventana "${2:-}") || { echo "$w"; exit 1; }; maximiza "$w"; echo "Maximizada";;
|
||||||
|
restaura) w=$(una_ventana "${2:-}") || { echo "$w"; exit 1; }; desmaximiza "$w"; echo "Restaurada a su tamaño";;
|
||||||
|
minimiza) w=$(una_ventana "${2:-}") || { echo "$w"; exit 1; }
|
||||||
|
xdotool windowminimize "$w" 2>/dev/null; echo "Minimizada";;
|
||||||
|
|
||||||
|
escritorio)
|
||||||
|
w=$(una_ventana "${2:-}") || { echo "$w"; exit 1; }
|
||||||
|
n=${3:-1}
|
||||||
|
case "$n" in una|uno|primero) n=1;; dos|segundo) n=2;; tres|tercero) n=3;; cuatro) n=4;; esac
|
||||||
|
total=$(xdotool get_num_desktops 2>/dev/null || echo 1)
|
||||||
|
[ "$n" -ge 1 ] 2>/dev/null && [ "$n" -le "$total" ] || { echo "no hay escritorio $n, solo $total"; exit 1; }
|
||||||
|
xdotool set_desktop_for_window "$w" $(( n - 1 )) 2>/dev/null
|
||||||
|
echo "Movida al escritorio $n"
|
||||||
|
;;
|
||||||
|
|
||||||
|
*) sed -n '2,26p' "$0"; exit 1;;
|
||||||
|
esac
|
||||||
8
config/whisper-server-cuda.sh
Executable file
8
config/whisper-server-cuda.sh
Executable file
|
|
@ -0,0 +1,8 @@
|
||||||
|
#!/usr/bin/env bash
|
||||||
|
# Envoltorio: el whisper-server de Newelle, pero el nuestro compilado con CUDA.
|
||||||
|
# Newelle lo invoca por flatpak-spawn --host esperando 'whisper-server' en el
|
||||||
|
# PATH; aqui se fija el entorno de CUDA (que el binario necesita para ver las
|
||||||
|
# libs) y se pasa a nuestra version con GPU. Los argumentos (-m, --port, -l...)
|
||||||
|
# los pone Newelle y se reenvian tal cual.
|
||||||
|
export LD_LIBRARY_PATH=/usr/local/cuda/lib64:${LD_LIBRARY_PATH:-}
|
||||||
|
exec "$HOME/COFRE/CODERS/JARVIS/voz/whisper-cuda/whisper.cpp/build/bin/whisper-server" "$@"
|
||||||
46
config/whisper-server-envoltorio.sh
Executable file
46
config/whisper-server-envoltorio.sh
Executable file
|
|
@ -0,0 +1,46 @@
|
||||||
|
#!/usr/bin/env bash
|
||||||
|
# Envoltorio: el whisper-server de Newelle, pero el nuestro compilado con CUDA.
|
||||||
|
# Newelle lo invoca por flatpak-spawn --host esperando 'whisper-server' en el
|
||||||
|
# PATH; aqui se fija el entorno de CUDA (que el binario necesita para ver las
|
||||||
|
# libs) y se pasa a nuestra version con GPU. Los argumentos (-m, --port, -l...)
|
||||||
|
# los pone Newelle y se reenvian tal cual.
|
||||||
|
#
|
||||||
|
# Copia versionada: ~/COFRE/CODERS/JARVIS/config/whisper-server-envoltorio.sh
|
||||||
|
export LD_LIBRARY_PATH=/usr/local/cuda/lib64:${LD_LIBRARY_PATH:-}
|
||||||
|
|
||||||
|
BINARIO="$HOME/COFRE/CODERS/JARVIS/voz/whisper-cuda/whisper.cpp/build/bin/whisper-server"
|
||||||
|
REGISTRO="$HOME/COFRE/CODERS/JARVIS/voz/whisper-arranques.log"
|
||||||
|
|
||||||
|
# Cuanta VRAM libre exigimos para arrancar en GPU. El modelo small ocupa 757 MiB
|
||||||
|
# en reposo pero llega a 839 en el pico de una transcripcion: pedir solo lo que
|
||||||
|
# ocupa al cargar es justo el error que hacia que cargase bien y muriese al
|
||||||
|
# hablarle, con un "Error recognizing file with server" que no explicaba nada.
|
||||||
|
# 950 deja holgura para el pico y para el contexto de CUDA.
|
||||||
|
MINIMO_MIB=${JARVIS_WHISPER_MIN_VRAM:-950}
|
||||||
|
|
||||||
|
# Barrer el servidor anterior antes de levantar el nuestro.
|
||||||
|
#
|
||||||
|
# Newelle lo lanza por flatpak-spawn --host, asi que el proceso vive FUERA del
|
||||||
|
# sandbox y no se entera de que la app se cerro: cada vez que se reinicia
|
||||||
|
# JARVIS queda un whisper-server huerfano agarrado a 757 MiB de la tarjeta.
|
||||||
|
# Dos o tres reinicios y ya no cabe el modelo del asistente, con el sintoma
|
||||||
|
# repartido —a veces va, a veces no— segun cuantos hubiera quedado sueltos.
|
||||||
|
#
|
||||||
|
# Se comparan PIDs y no patrones: un `pkill -f whisper-server` desde aqui se
|
||||||
|
# mataria a si mismo, que este script tiene ese nombre.
|
||||||
|
for otro in $(pgrep -x whisper-server 2>/dev/null); do
|
||||||
|
[ "$otro" = "$$" ] && continue
|
||||||
|
kill "$otro" 2>/dev/null
|
||||||
|
done
|
||||||
|
|
||||||
|
libre=$(nvidia-smi --query-gpu=memory.free --format=csv,noheader,nounits 2>/dev/null | head -1)
|
||||||
|
|
||||||
|
if [ -n "$libre" ] && [ "$libre" -lt "$MINIMO_MIB" ] 2>/dev/null; then
|
||||||
|
# Sin sitio: mejor transcribir en procesador que abortar. Es mas lento, pero
|
||||||
|
# responde; abortar deja la app muda y sin decir por que.
|
||||||
|
echo "$(date '+%F %T') GPU con solo ${libre} MiB libres (<${MINIMO_MIB}): al procesador" >> "$REGISTRO"
|
||||||
|
exec "$BINARIO" --no-gpu "$@"
|
||||||
|
fi
|
||||||
|
|
||||||
|
echo "$(date '+%F %T') GPU con ${libre:-?} MiB libres: en tarjeta" >> "$REGISTRO"
|
||||||
|
exec "$BINARIO" "$@"
|
||||||
150
config/wiki_ingesta.py
Normal file
150
config/wiki_ingesta.py
Normal file
|
|
@ -0,0 +1,150 @@
|
||||||
|
#!/usr/bin/env python3
|
||||||
|
"""Descarga articulos de Wikipedia en espanol sobre los temas de JARVIS y los
|
||||||
|
deja como .txt en la carpeta de documentos del RAG. Luego, construir_indice.py
|
||||||
|
los vectoriza. Corre en el host (solo stdlib + red), sin sonido ni GPU.
|
||||||
|
|
||||||
|
python3 config/wiki_ingesta.py # descarga
|
||||||
|
# despues, dentro del flatpak:
|
||||||
|
flatpak run --command=python3 io.github.qwersyk.Newelle//master \
|
||||||
|
~/COFRE/CODERS/JARVIS/config/construir_indice.py
|
||||||
|
|
||||||
|
Es aditivo: agrega ficheros a la carpeta, no borra lo que ya haya.
|
||||||
|
"""
|
||||||
|
import os, json, time, urllib.parse, urllib.request, urllib.error
|
||||||
|
|
||||||
|
API = "https://es.wikipedia.org/w/api.php"
|
||||||
|
UA = "JARVIS-local-RAG/1.0 (asistente de voz local; contacto: local)"
|
||||||
|
DOCS = os.path.expanduser(
|
||||||
|
"~/.var/app/io.github.qwersyk.Newelle/config/models/documents")
|
||||||
|
|
||||||
|
# Por tema: semillas seguras + una busqueda que amplia con articulos afines.
|
||||||
|
TEMAS = {
|
||||||
|
"tecnologia": {
|
||||||
|
"buscar": ["tecnología", "informática", "hardware", "red informática",
|
||||||
|
"inteligencia artificial", "sistema operativo"],
|
||||||
|
"semillas": ["Tecnología", "Informática", "Internet", "Protocolo de red",
|
||||||
|
"Microprocesador", "Computación en la nube", "Base de datos"],
|
||||||
|
},
|
||||||
|
"criptografia": {
|
||||||
|
"buscar": ["criptografía", "cifrado", "criptografía asimétrica"],
|
||||||
|
"semillas": ["Criptografía", "Cifrado", "RSA", "Advanced Encryption Standard",
|
||||||
|
"Función hash criptográfica", "Firma digital",
|
||||||
|
"Diffie-Hellman", "Pretty Good Privacy", "Transport Layer Security",
|
||||||
|
"Criptografía de curva elíptica", "Cadena de bloques",
|
||||||
|
"Bitcoin", "Criptomoneda"],
|
||||||
|
},
|
||||||
|
"software_libre": {
|
||||||
|
"buscar": ["software libre", "código abierto", "historia de Linux"],
|
||||||
|
"semillas": ["Software libre", "GNU", "Richard Stallman", "GNU/Linux",
|
||||||
|
"Linus Torvalds", "Free Software Foundation", "Licencia pública general de GNU",
|
||||||
|
"Código abierto", "Debian", "Unix", "Kernel Linux",
|
||||||
|
"Movimiento del software libre"],
|
||||||
|
},
|
||||||
|
"hacking": {
|
||||||
|
"buscar": ["seguridad informática", "hacker", "ciberseguridad"],
|
||||||
|
"semillas": ["Hacker", "Seguridad informática", "Hacker (seguridad informática)",
|
||||||
|
"Malware", "Exploit", "Ingeniería social (seguridad informática)",
|
||||||
|
"Phreaking", "Kevin Mitnick", "Anonymous (colectivo)",
|
||||||
|
"Prueba de penetración", "Vulnerabilidad (informática)",
|
||||||
|
"Cortafuegos (informática)", "Ataque de denegación de servicio"],
|
||||||
|
},
|
||||||
|
"clima": {
|
||||||
|
"buscar": ["cambio climático", "calentamiento global", "clima"],
|
||||||
|
"semillas": ["Cambio climático", "Calentamiento global", "Efecto invernadero",
|
||||||
|
"Gas de efecto invernadero", "Protocolo de Kioto",
|
||||||
|
"Acuerdo de París", "IPCC", "Clima", "Dióxido de carbono",
|
||||||
|
"El Niño", "Nivel del mar", "Energía renovable"],
|
||||||
|
},
|
||||||
|
"conflictos_espana": {
|
||||||
|
"buscar": ["guerra en España", "conflicto España historia"],
|
||||||
|
"semillas": ["Guerra civil española", "Transición española",
|
||||||
|
"Guerra de la Independencia Española", "Guerras carlistas",
|
||||||
|
"Reconquista", "Dictadura de Francisco Franco",
|
||||||
|
"Segunda República Española", "Movimiento 15-M",
|
||||||
|
"Conflicto vasco", "Guerra de Sucesión Española"],
|
||||||
|
},
|
||||||
|
}
|
||||||
|
|
||||||
|
BUSCAR_POR_CONSULTA = 15 # articulos extra por cada busqueda
|
||||||
|
PAUSA = 0.8 # cortesia con la API (subida tras el 429)
|
||||||
|
|
||||||
|
|
||||||
|
def _get(params, reintentos=5):
|
||||||
|
params = {**params, "format": "json"}
|
||||||
|
url = API + "?" + urllib.parse.urlencode(params)
|
||||||
|
req = urllib.request.Request(url, headers={"User-Agent": UA})
|
||||||
|
espera = 2.0
|
||||||
|
for intento in range(reintentos):
|
||||||
|
try:
|
||||||
|
with urllib.request.urlopen(req, timeout=30) as r:
|
||||||
|
return json.load(r)
|
||||||
|
except urllib.error.HTTPError as e:
|
||||||
|
if e.code == 429 and intento < reintentos - 1:
|
||||||
|
# Wikipedia nos frena: esperar cada vez mas (backoff)
|
||||||
|
time.sleep(espera)
|
||||||
|
espera *= 2
|
||||||
|
continue
|
||||||
|
raise
|
||||||
|
raise RuntimeError("agotados los reintentos")
|
||||||
|
|
||||||
|
|
||||||
|
def titulos_de_busqueda(consulta, limite):
|
||||||
|
try:
|
||||||
|
d = _get({"action": "query", "list": "search",
|
||||||
|
"srsearch": consulta, "srlimit": limite})
|
||||||
|
return [h["title"] for h in d.get("query", {}).get("search", [])]
|
||||||
|
except Exception as e:
|
||||||
|
print(f" busqueda '{consulta}' fallo: {e}")
|
||||||
|
return []
|
||||||
|
|
||||||
|
|
||||||
|
def extracto(titulo):
|
||||||
|
try:
|
||||||
|
d = _get({"action": "query", "prop": "extracts", "explaintext": 1,
|
||||||
|
"redirects": 1, "titles": titulo})
|
||||||
|
paginas = d.get("query", {}).get("pages", {})
|
||||||
|
for _, pg in paginas.items():
|
||||||
|
txt = pg.get("extract", "")
|
||||||
|
if txt and len(txt) > 300:
|
||||||
|
return pg.get("title", titulo), txt
|
||||||
|
except Exception as e:
|
||||||
|
print(f" extracto '{titulo}' fallo: {e}")
|
||||||
|
return None, None
|
||||||
|
|
||||||
|
|
||||||
|
def slug(s):
|
||||||
|
s = "".join(c if c.isalnum() else "_" for c in s.lower())
|
||||||
|
return s.strip("_")[:80]
|
||||||
|
|
||||||
|
|
||||||
|
def main():
|
||||||
|
os.makedirs(DOCS, exist_ok=True)
|
||||||
|
total = 0
|
||||||
|
for tema, cfg in TEMAS.items():
|
||||||
|
print(f"\n=== {tema} ===")
|
||||||
|
titulos = list(cfg["semillas"])
|
||||||
|
for consulta in cfg["buscar"]:
|
||||||
|
titulos += titulos_de_busqueda(consulta, BUSCAR_POR_CONSULTA)
|
||||||
|
time.sleep(PAUSA)
|
||||||
|
# dedup conservando orden
|
||||||
|
vistos, unicos = set(), []
|
||||||
|
for t in titulos:
|
||||||
|
if t.lower() not in vistos:
|
||||||
|
vistos.add(t.lower()); unicos.append(t)
|
||||||
|
for t in unicos:
|
||||||
|
dst = os.path.join(DOCS, f"wiki_{tema}_{slug(t)}.txt")
|
||||||
|
if os.path.exists(dst):
|
||||||
|
continue
|
||||||
|
titulo_real, txt = extracto(t)
|
||||||
|
time.sleep(PAUSA)
|
||||||
|
if not txt:
|
||||||
|
continue
|
||||||
|
with open(dst, "w", encoding="utf-8") as f:
|
||||||
|
f.write(f"# {titulo_real}\n(Wikipedia, tema: {tema})\n\n{txt}\n")
|
||||||
|
total += 1
|
||||||
|
print(f" [{total}] {titulo_real} ({len(txt)//1024} KB)")
|
||||||
|
print(f"\nlisto: {total} articulos nuevos en {DOCS}")
|
||||||
|
|
||||||
|
|
||||||
|
if __name__ == "__main__":
|
||||||
|
main()
|
||||||
61
entrena/README.md
Normal file
61
entrena/README.md
Normal file
|
|
@ -0,0 +1,61 @@
|
||||||
|
# Entrenamiento de JARVIS
|
||||||
|
|
||||||
|
El fine-tuning NO sustituye al RAG (nucleo/saber/), lo complementa. El RAG ya
|
||||||
|
funciona y da el conocimiento fresco; esto hornea el estilo y los flujos en los
|
||||||
|
pesos. Por eso fue: primero RAG, esto despues.
|
||||||
|
|
||||||
|
## Los tres pasos
|
||||||
|
|
||||||
|
1. dataset.py convierte los apuntes de COFRE en pares pregunta-respuesta
|
||||||
|
(usa el indice de nucleo/saber/, ~10 h con el 4B local)
|
||||||
|
2. afina.py QLoRA sobre el dataset. --revisa dice si la maquina puede
|
||||||
|
3. exportar el adaptador a GGUF + Modelfile con ADAPTER, para ollama
|
||||||
|
|
||||||
|
## Por que falla hoy: qwen3.5 es MULTIMODAL (16 ago)
|
||||||
|
|
||||||
|
Las pruebas de `afina.py` cargan el modelo bien y se caen justo despues, al
|
||||||
|
enganchar los adaptadores, con un mensaje que no viene a cuento:
|
||||||
|
|
||||||
|
Incorrect image source. Must be a valid URL starting with `http://`
|
||||||
|
|
||||||
|
No es un fallo de red ni de rutas. **`Qwen/Qwen3.5-2B` es `image-text-to-text`**
|
||||||
|
—comprobado en la API de HuggingFace, y el propio GGUF lo delata: el
|
||||||
|
`model_info` de ollama trae `qwen35.vision.block_count = 24`—. O sea que el
|
||||||
|
modelo lleva torre de vision, y `FastLanguageModel` lo mete por el camino de
|
||||||
|
solo texto mientras transformers intenta procesar una imagen que no existe.
|
||||||
|
|
||||||
|
La pista estaba en el log y se leyo como ruido:
|
||||||
|
|
||||||
|
Unsloth: Explicit target_modules are constrained by the
|
||||||
|
finetune_(vision|language|attention|mlp) filters
|
||||||
|
|
||||||
|
Ese aviso solo lo emite el camino multimodal.
|
||||||
|
|
||||||
|
Por donde va el arreglo: `FastVisionModel` con `finetune_vision_layers=False`,
|
||||||
|
que es la via de unsloth para afinar solo la parte de lenguaje de un modelo con
|
||||||
|
vision. **Sin probar todavia.**
|
||||||
|
|
||||||
|
De paso, los nombres que no existen en HuggingFace y que las pruebas fueron
|
||||||
|
descartando: `Qwen3.5-3B`, `Qwen3.5-3B-Instruct`, `Qwen3.5-1.7B`,
|
||||||
|
`Qwen3.5-1.7B-Instruct`, `Qwen3.5-1.5B`. El unico que carga es `Qwen3.5-2B`
|
||||||
|
(1,95 GB).
|
||||||
|
|
||||||
|
## Donde entrenar
|
||||||
|
|
||||||
|
T1200 (4 GB) al limite. Turing, sin bf16. Posible pero fragil.
|
||||||
|
3060 (12 GB) holgado. El sitio natural. El dataset viaja como fichero.
|
||||||
|
|
||||||
|
## Para entrenar
|
||||||
|
|
||||||
|
pip install unsloth # trae peft, trl, bitsandbytes
|
||||||
|
./afina.py --revisa # comprueba
|
||||||
|
./afina.py # entrena
|
||||||
|
|
||||||
|
## Exportar a ollama (tras entrenar)
|
||||||
|
|
||||||
|
# con llama.cpp:
|
||||||
|
python convert_lora_to_gguf.py jarvis-lora --outfile jarvis-lora.gguf
|
||||||
|
# Modelfile:
|
||||||
|
# FROM qwen3.5:4b
|
||||||
|
# ADAPTER ./jarvis-lora.gguf
|
||||||
|
ollama create qwen3.5:4b-jarvis-cofre -f Modelfile
|
||||||
236
entrena/afina.py
Executable file
236
entrena/afina.py
Executable file
|
|
@ -0,0 +1,236 @@
|
||||||
|
#!/usr/bin/env python3
|
||||||
|
"""Fine-tuning de JARVIS con QLoRA sobre el dataset de COFRE.
|
||||||
|
|
||||||
|
./afina.py --revisa comprueba que se puede entrenar aqui, sin entrenar
|
||||||
|
./afina.py entrena (largo; mejor en el servidor con la 3060)
|
||||||
|
|
||||||
|
## Que hace y que NO hace el fine-tuning
|
||||||
|
|
||||||
|
Le enseña al modelo el ESTILO y las respuestas de tus apuntes con ejemplos. NO
|
||||||
|
sustituye al RAG: el RAG le da los datos frescos en el momento —y se actualiza
|
||||||
|
soltando un fichero—, mientras que esto los hornea en los pesos. Se complementan:
|
||||||
|
el fine-tuning hace que "suene" a JARVIS y conozca tus flujos sin buscar; el RAG
|
||||||
|
cubre lo que cambia y lo que es muy especifico.
|
||||||
|
|
||||||
|
Por eso el orden fue: primero RAG (hecho, funciona hoy), y esto despues.
|
||||||
|
|
||||||
|
## QLoRA en cristiano
|
||||||
|
|
||||||
|
Entrenar un 4B entero pide mas memoria de la que hay. QLoRA hace dos trucos:
|
||||||
|
- carga el modelo base en 4 bits (cabe en poca VRAM, y se queda CONGELADO)
|
||||||
|
- entrena solo unas matrices pequeñas nuevas (los "adaptadores LoRA"), que son
|
||||||
|
una fraccion del tamaño
|
||||||
|
|
||||||
|
Asi se entrena un 4B en pocos GB. El resultado es un adaptador de ~50 MB que se
|
||||||
|
le pone encima al modelo base.
|
||||||
|
|
||||||
|
## Donde entrenar
|
||||||
|
|
||||||
|
T1200 (4 GB, esta maquina) al limite. Turing (capacidad 7.5): sin bf16 ni
|
||||||
|
flash-attention. Posible con lote 1 y secuencia
|
||||||
|
corta, lento y fragil. --revisa lo dice.
|
||||||
|
3060 (12 GB, el servidor) holgado. Ampere: bf16 y flash-attention. Es el
|
||||||
|
sitio natural, por eso el dataset se genera aparte
|
||||||
|
y viaja como fichero.
|
||||||
|
|
||||||
|
## Dependencias
|
||||||
|
|
||||||
|
pip install unsloth (trae peft, trl, bitsandbytes, accelerate)
|
||||||
|
|
||||||
|
unsloth porque es lo que mejor exprime una GPU pequeña: mismo resultado con la
|
||||||
|
mitad de VRAM y el doble de velocidad que peft+trl a pelo.
|
||||||
|
"""
|
||||||
|
import argparse
|
||||||
|
import json
|
||||||
|
import os
|
||||||
|
import sys
|
||||||
|
|
||||||
|
AQUI = os.path.dirname(os.path.abspath(__file__))
|
||||||
|
DATASET = os.path.join(AQUI, "dataset-cofre.jsonl")
|
||||||
|
SALIDA = os.path.join(AQUI, "jarvis-lora")
|
||||||
|
|
||||||
|
# El modelo base, en formato HuggingFace. ollama corre GGUF; para entrenar hace
|
||||||
|
# falta el modelo de verdad. Se prueban candidatos en orden hasta que uno
|
||||||
|
# cargue: la version pre-cuantizada de unsloth va primero porque baja menos y
|
||||||
|
# ocupa menos VRAM, que en 4 GB es lo que decide si entra.
|
||||||
|
#
|
||||||
|
# El de ollama es qwen3.5:4b (arquitectura qwen35, 4,7B, embedding 2560). Si
|
||||||
|
# ninguno carga, la fase 0 lo dice y no se pierden horas.
|
||||||
|
CANDIDATOS = [
|
||||||
|
os.environ.get("JARVIS_BASE_HF", ""), # lo que ponga el usuario, si pone
|
||||||
|
"unsloth/Qwen3.5-4B-Instruct-bnb-4bit",
|
||||||
|
"Qwen/Qwen3.5-4B-Instruct",
|
||||||
|
"unsloth/Qwen3.5-4B-bnb-4bit",
|
||||||
|
"Qwen/Qwen3.5-4B",
|
||||||
|
]
|
||||||
|
|
||||||
|
# Apretado para 4 GB (ver el plan). Con el 4,7B en 4 bits ocupando ~2,8 GB,
|
||||||
|
# cada megabyte de mas en secuencia o rango es el que provoca el OOM.
|
||||||
|
EPOCAS = 2
|
||||||
|
LOTE = 1
|
||||||
|
ACUMULA = 16 # lote efectivo 16 sin gastar VRAM
|
||||||
|
LR = 2e-4
|
||||||
|
MAX_SEQ = 512 # los pares Q&A son cortos; 512 no pierde casi nada
|
||||||
|
RANGO = 8 # adaptadores pequeños
|
||||||
|
|
||||||
|
|
||||||
|
def _base_que_carga():
|
||||||
|
"""El primer candidato que exista y cargue. None si ninguno."""
|
||||||
|
from unsloth import FastLanguageModel
|
||||||
|
for repo in CANDIDATOS:
|
||||||
|
if not repo:
|
||||||
|
continue
|
||||||
|
try:
|
||||||
|
print(f" probando {repo} ...", flush=True)
|
||||||
|
modelo, tok = FastLanguageModel.from_pretrained(
|
||||||
|
model_name=repo, max_seq_length=MAX_SEQ, dtype=None,
|
||||||
|
load_in_4bit=True)
|
||||||
|
print(f" ✓ carga: {repo}")
|
||||||
|
return repo, modelo, tok
|
||||||
|
except Exception as e:
|
||||||
|
print(f" no: {str(e).splitlines()[0][:80]}")
|
||||||
|
return None, None, None
|
||||||
|
|
||||||
|
|
||||||
|
def revisa() -> int:
|
||||||
|
"""El ensayo de la fase 0: carga el 4,7B y hace UN paso de entrenamiento.
|
||||||
|
|
||||||
|
Es el momento de la verdad. Si ese paso pasa sin quedarse sin memoria, el
|
||||||
|
entrenamiento entero es cuestion de tiempo. Si peta, se sabe en diez minutos
|
||||||
|
y no en la sexta hora.
|
||||||
|
"""
|
||||||
|
print("\n ── se puede entrenar aqui? ──\n")
|
||||||
|
|
||||||
|
n = 0
|
||||||
|
if os.path.exists(DATASET):
|
||||||
|
with open(DATASET) as f:
|
||||||
|
n = sum(1 for _ in f)
|
||||||
|
print(f" dataset: {n} ejemplos"
|
||||||
|
+ (" (suficiente para el test; poco para entrenar)" if n < 500 else ""))
|
||||||
|
|
||||||
|
try:
|
||||||
|
import torch
|
||||||
|
except ImportError:
|
||||||
|
print(" torch: NO — el venv de entrenamiento no esta montado")
|
||||||
|
return 1
|
||||||
|
if not torch.cuda.is_available():
|
||||||
|
print(" cuda: NO")
|
||||||
|
return 1
|
||||||
|
p = torch.cuda.get_device_properties(0)
|
||||||
|
libre = torch.cuda.mem_get_info()[0] / 1e9
|
||||||
|
print(f" gpu: {p.name} {p.total_memory/1e9:.1f} GB, {libre:.1f} libres, "
|
||||||
|
f"capacidad {p.major}.{p.minor}"
|
||||||
|
+ (" (Turing: fp16, sin flash-attn)" if p.major < 8 else ""))
|
||||||
|
if libre < 3.3:
|
||||||
|
print(" AVISO: hay menos de 3,3 GB libres. Cierra JARVIS y ollama antes.")
|
||||||
|
|
||||||
|
for m in ("unsloth", "peft", "trl", "bitsandbytes"):
|
||||||
|
try:
|
||||||
|
__import__(m)
|
||||||
|
except ImportError:
|
||||||
|
print(f" {m}: NO -> el venv de entrenamiento no acabo de instalar")
|
||||||
|
return 1
|
||||||
|
|
||||||
|
# El momento de la verdad: cargar + un paso real.
|
||||||
|
print("\n ── cargando el modelo y haciendo un paso de prueba ──")
|
||||||
|
from unsloth import FastLanguageModel
|
||||||
|
repo, modelo, tok = _base_que_carga()
|
||||||
|
if repo is None:
|
||||||
|
print("\n NINGUN candidato cargo. O no existe el repo HF del qwen3.5:4b,")
|
||||||
|
print(" o esta arquitectura (qwen35) no la soporta este transformers.")
|
||||||
|
print(" Pon el repo correcto en JARVIS_BASE_HF y reintenta.")
|
||||||
|
return 1
|
||||||
|
|
||||||
|
tras_modelo = torch.cuda.memory_allocated() / 1e9
|
||||||
|
print(f" VRAM tras cargar el modelo: {tras_modelo:.2f} GB")
|
||||||
|
|
||||||
|
modelo = FastLanguageModel.get_peft_model(
|
||||||
|
modelo, r=RANGO, lora_alpha=RANGO, lora_dropout=0,
|
||||||
|
target_modules=["q_proj", "k_proj", "v_proj", "o_proj",
|
||||||
|
"gate_proj", "up_proj", "down_proj"],
|
||||||
|
use_gradient_checkpointing="unsloth", random_state=42)
|
||||||
|
|
||||||
|
# un lote de una frase, forward + backward, que es donde revienta si revienta
|
||||||
|
try:
|
||||||
|
import torch as T
|
||||||
|
texto = tok.apply_chat_template(
|
||||||
|
[{"role": "user", "content": "que es secretsdump"},
|
||||||
|
{"role": "assistant", "content": "Saca los hashes NTLM, señor."}],
|
||||||
|
tokenize=False)
|
||||||
|
ids = tok(texto, return_tensors="pt", max_length=MAX_SEQ,
|
||||||
|
truncation=True).input_ids.to("cuda")
|
||||||
|
salida = modelo(ids, labels=ids)
|
||||||
|
salida.loss.backward()
|
||||||
|
pico = T.cuda.max_memory_allocated() / 1e9
|
||||||
|
print(f" ✓ un paso de entrenamiento paso. Pico de VRAM: {pico:.2f} GB")
|
||||||
|
print(f"\n CABE. base a usar: {repo}")
|
||||||
|
print(" Pon ese repo en JARVIS_BASE_HF si no es el primero, y ./afina.py\n")
|
||||||
|
return 0
|
||||||
|
except T.cuda.OutOfMemoryError:
|
||||||
|
print("\n OOM: el 4,7B no entra en esta grafica ni apretando.")
|
||||||
|
print(" Plan B: bajar MAX_SEQ a 256, o el 3B, o el servidor (3060).")
|
||||||
|
return 2
|
||||||
|
|
||||||
|
|
||||||
|
def entrena() -> int:
|
||||||
|
if not os.path.exists(DATASET):
|
||||||
|
print(" no hay dataset: ./dataset.py primero")
|
||||||
|
return 1
|
||||||
|
|
||||||
|
import torch
|
||||||
|
from unsloth import FastLanguageModel
|
||||||
|
from datasets import load_dataset
|
||||||
|
from trl import SFTTrainer, SFTConfig
|
||||||
|
|
||||||
|
ampere = torch.cuda.get_device_properties(0).major >= 8
|
||||||
|
|
||||||
|
repo, modelo, tokenizer = _base_que_carga()
|
||||||
|
if repo is None:
|
||||||
|
print(" ningun base cargo; corre --revisa para el diagnostico")
|
||||||
|
return 1
|
||||||
|
|
||||||
|
modelo = FastLanguageModel.get_peft_model(
|
||||||
|
modelo, r=RANGO, lora_alpha=RANGO, lora_dropout=0,
|
||||||
|
target_modules=["q_proj", "k_proj", "v_proj", "o_proj",
|
||||||
|
"gate_proj", "up_proj", "down_proj"],
|
||||||
|
use_gradient_checkpointing="unsloth", random_state=42)
|
||||||
|
|
||||||
|
datos = load_dataset("json", data_files=DATASET, split="train")
|
||||||
|
|
||||||
|
def formatea(ej):
|
||||||
|
return {"text": tokenizer.apply_chat_template(
|
||||||
|
ej["messages"], tokenize=False, add_generation_prompt=False)}
|
||||||
|
datos = datos.map(formatea)
|
||||||
|
|
||||||
|
entrenador = SFTTrainer(
|
||||||
|
model=modelo, tokenizer=tokenizer, train_dataset=datos,
|
||||||
|
dataset_text_field="text", max_seq_length=MAX_SEQ,
|
||||||
|
args=SFTConfig(
|
||||||
|
per_device_train_batch_size=LOTE,
|
||||||
|
gradient_accumulation_steps=ACUMULA,
|
||||||
|
num_train_epochs=EPOCAS, learning_rate=LR,
|
||||||
|
fp16=not ampere, bf16=ampere,
|
||||||
|
logging_steps=10, optim="adamw_8bit",
|
||||||
|
warmup_ratio=0.05, lr_scheduler_type="cosine",
|
||||||
|
output_dir=os.path.join(AQUI, "checkpoints"), seed=42))
|
||||||
|
|
||||||
|
print(" entrenando...")
|
||||||
|
entrenador.train()
|
||||||
|
|
||||||
|
modelo.save_pretrained(SALIDA)
|
||||||
|
tokenizer.save_pretrained(SALIDA)
|
||||||
|
print(f"\n adaptador guardado: {SALIDA}")
|
||||||
|
print(" para usarlo con ollama hay que exportarlo a GGUF y crear un")
|
||||||
|
print(" Modelfile con ADAPTER. Ver el README de entrena/.")
|
||||||
|
return 0
|
||||||
|
|
||||||
|
|
||||||
|
def main() -> int:
|
||||||
|
p = argparse.ArgumentParser()
|
||||||
|
p.add_argument("--revisa", action="store_true")
|
||||||
|
a = p.parse_args()
|
||||||
|
return revisa() if a.revisa else entrena()
|
||||||
|
|
||||||
|
|
||||||
|
if __name__ == "__main__":
|
||||||
|
sys.exit(main())
|
||||||
171
entrena/dataset.py
Executable file
171
entrena/dataset.py
Executable file
|
|
@ -0,0 +1,171 @@
|
||||||
|
#!/usr/bin/env python3
|
||||||
|
"""Genera el dataset de fine-tuning a partir de los apuntes de COFRE.
|
||||||
|
|
||||||
|
./dataset.py --muestra 5 enseña 5 ejemplos y para (para mirar la calidad)
|
||||||
|
./dataset.py genera el dataset entero (horas, en segundo plano)
|
||||||
|
|
||||||
|
## Por que esto es el paso que faltaba
|
||||||
|
|
||||||
|
Fine-tuning no es magia: es enseñarle al modelo con EJEMPLOS de como quieres que
|
||||||
|
conteste. Para eso hacen falta pares pregunta-respuesta, y no los teniamos. Los
|
||||||
|
apuntes de COFRE son conocimiento, pero en prosa; hay que convertirlos en la
|
||||||
|
forma "alguien pregunta X, JARVIS responde Y".
|
||||||
|
|
||||||
|
Se generan con el modelo local a partir de cada fragmento de los apuntes: se le
|
||||||
|
da el trozo y se le pide que invente las preguntas que ese trozo contesta, y la
|
||||||
|
respuesta al estilo de JARVIS. El fragmento es la VERDAD —lo escribio el
|
||||||
|
usuario— asi que las respuestas salen de ahi y no de lo que el modelo recuerde.
|
||||||
|
|
||||||
|
## Por que el dataset vale aunque no se entrene aqui
|
||||||
|
|
||||||
|
La T1200 de 4 GB va justa para entrenar un 4B. El sitio natural es el servidor
|
||||||
|
con la 3060 de 12 GB. Pero el DATASET es lo caro de conseguir y no depende de la
|
||||||
|
maquina: se genera una vez, es un fichero, y se entrena donde haga falta —aqui
|
||||||
|
si cabe, o en el servidor cuando haya acceso—.
|
||||||
|
|
||||||
|
## El formato
|
||||||
|
|
||||||
|
JSONL en el formato de mensajes, que es lo que comen trl/axolotl/unsloth:
|
||||||
|
|
||||||
|
{"messages": [{"role":"user","content":"..."},
|
||||||
|
{"role":"assistant","content":"..."}]}
|
||||||
|
"""
|
||||||
|
import argparse
|
||||||
|
import json
|
||||||
|
import os
|
||||||
|
import re
|
||||||
|
import sys
|
||||||
|
import urllib.request
|
||||||
|
|
||||||
|
AQUI = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
|
||||||
|
INDICE = os.path.join(AQUI, "nucleo", "datos", "saber.jsonl")
|
||||||
|
SALIDA = os.path.join(AQUI, "entrena", "dataset-cofre.jsonl")
|
||||||
|
ENDPOINT = os.environ.get("JARVIS_OLLAMA", "http://127.0.0.1:11434")
|
||||||
|
MODELO = os.environ.get("JARVIS_MODELO", "qwen3.5:4b-jarvis")
|
||||||
|
|
||||||
|
# Al generador se le da MAS libertad que a JARVIS en produccion: aqui quereis
|
||||||
|
# variedad de preguntas, no una respuesta conservadora.
|
||||||
|
GENERADOR = """Eres un generador de datos de entrenamiento para un asistente de
|
||||||
|
pentesting llamado JARVIS. Te doy un fragmento de los apuntes tecnicos del
|
||||||
|
usuario. Devuelve de UNA a TRES preguntas que una persona haria y que ese
|
||||||
|
fragmento contesta, cada una con su respuesta.
|
||||||
|
|
||||||
|
Reglas:
|
||||||
|
- Las preguntas, naturales y variadas: como las diria alguien por voz.
|
||||||
|
- Las respuestas SALEN DEL FRAGMENTO. Si el fragmento tiene un comando exacto,
|
||||||
|
la respuesta lo lleva tal cual. No te inventes flags que no aparezcan.
|
||||||
|
- Respuestas al estilo de JARVIS: directas, en castellano, tratando de "señor".
|
||||||
|
- Si el fragmento no da para una pregunta util (es un titulo, una lista de
|
||||||
|
enlaces, ruido), devuelve una lista vacia.
|
||||||
|
|
||||||
|
Responde SOLO con JSON, un objeto con la clave "pares":
|
||||||
|
{"pares": [{"pregunta": "...", "respuesta": "..."}]}"""
|
||||||
|
|
||||||
|
|
||||||
|
def _pide(fragmento: str) -> list:
|
||||||
|
cuerpo = json.dumps({
|
||||||
|
"model": MODELO,
|
||||||
|
"messages": [{"role": "system", "content": GENERADOR},
|
||||||
|
{"role": "user", "content": fragmento[:1500]}],
|
||||||
|
"stream": False, "think": False,
|
||||||
|
"options": {"temperature": 0.7, "num_predict": 500},
|
||||||
|
"format": "json",
|
||||||
|
}).encode()
|
||||||
|
req = urllib.request.Request(ENDPOINT + "/api/chat", data=cuerpo,
|
||||||
|
headers={"Content-Type": "application/json"})
|
||||||
|
try:
|
||||||
|
with urllib.request.urlopen(req, timeout=120) as r:
|
||||||
|
contenido = json.loads(r.read())["message"]["content"]
|
||||||
|
except Exception:
|
||||||
|
return []
|
||||||
|
# el modelo a veces envuelve el array en un objeto {"pares": [...]}
|
||||||
|
try:
|
||||||
|
d = json.loads(contenido)
|
||||||
|
except json.JSONDecodeError:
|
||||||
|
m = re.search(r"\[.*\]", contenido, re.S)
|
||||||
|
if not m:
|
||||||
|
return []
|
||||||
|
try:
|
||||||
|
d = json.loads(m.group(0))
|
||||||
|
except json.JSONDecodeError:
|
||||||
|
return []
|
||||||
|
if isinstance(d, dict):
|
||||||
|
d = next((v for v in d.values() if isinstance(v, list)), [])
|
||||||
|
salida = []
|
||||||
|
for par in d if isinstance(d, list) else []:
|
||||||
|
if isinstance(par, dict) and par.get("pregunta") and par.get("respuesta"):
|
||||||
|
salida.append((par["pregunta"].strip(), par["respuesta"].strip()))
|
||||||
|
return salida
|
||||||
|
|
||||||
|
|
||||||
|
def apuntes():
|
||||||
|
"""Los fragmentos de apuntes del indice, los mas sustanciosos primero."""
|
||||||
|
fuera = []
|
||||||
|
with open(INDICE, encoding="utf-8") as f:
|
||||||
|
for l in f:
|
||||||
|
try:
|
||||||
|
d = json.loads(l)
|
||||||
|
except json.JSONDecodeError:
|
||||||
|
continue
|
||||||
|
if d.get("tipo") == "apunte" and len(d["texto"].split()) >= 20:
|
||||||
|
d.pop("v", None)
|
||||||
|
fuera.append(d)
|
||||||
|
return fuera
|
||||||
|
|
||||||
|
|
||||||
|
def main() -> int:
|
||||||
|
p = argparse.ArgumentParser()
|
||||||
|
p.add_argument("--muestra", type=int, default=0,
|
||||||
|
help="genera solo N y los enseña, sin guardar")
|
||||||
|
a = p.parse_args()
|
||||||
|
|
||||||
|
if not os.path.exists(INDICE):
|
||||||
|
print(" no hay indice: nucleo/saber/indexa.py primero")
|
||||||
|
return 1
|
||||||
|
fragmentos = apuntes()
|
||||||
|
print(f" {len(fragmentos)} fragmentos con sustancia", flush=True)
|
||||||
|
|
||||||
|
if a.muestra:
|
||||||
|
for frag in fragmentos[:a.muestra]:
|
||||||
|
pares = _pide(frag["texto"])
|
||||||
|
print(f"\n ── {frag.get('fichero', frag['perfil'])} ──")
|
||||||
|
for q, r in pares:
|
||||||
|
print(f" P: {q}")
|
||||||
|
print(f" R: {r[:120]}")
|
||||||
|
return 0
|
||||||
|
|
||||||
|
# Reanudable: un trabajo de 10 h no puede perder todo si se corta. Se apunta
|
||||||
|
# en un .hecho por que fragmento se iba, y al arrancar se salta hasta ahi y
|
||||||
|
# se AÑADE al dataset en vez de reescribirlo.
|
||||||
|
marca = SALIDA + ".hecho"
|
||||||
|
desde = 0
|
||||||
|
if os.path.exists(marca) and os.path.exists(SALIDA):
|
||||||
|
try:
|
||||||
|
desde = int(open(marca).read().strip()) + 1
|
||||||
|
except (ValueError, OSError):
|
||||||
|
desde = 0
|
||||||
|
modo = "a" if desde else "w"
|
||||||
|
hechos = sum(1 for _ in open(SALIDA)) if desde and os.path.exists(SALIDA) else 0
|
||||||
|
if desde:
|
||||||
|
print(f" reanudando desde el fragmento {desde} ({hechos} ejemplos hechos)",
|
||||||
|
flush=True)
|
||||||
|
|
||||||
|
with open(SALIDA, modo, encoding="utf-8", buffering=1) as out:
|
||||||
|
for i in range(desde, len(fragmentos)):
|
||||||
|
for q, r in _pide(fragmentos[i]["texto"]):
|
||||||
|
out.write(json.dumps({"messages": [
|
||||||
|
{"role": "user", "content": q},
|
||||||
|
{"role": "assistant", "content": r},
|
||||||
|
]}, ensure_ascii=False) + "\n")
|
||||||
|
hechos += 1
|
||||||
|
with open(marca, "w") as m:
|
||||||
|
m.write(str(i))
|
||||||
|
if (i + 1) % 50 == 0:
|
||||||
|
print(f" {i+1}/{len(fragmentos)} fragmentos, {hechos} ejemplos",
|
||||||
|
flush=True)
|
||||||
|
print(f"\n dataset guardado: {SALIDA} ({hechos} ejemplos)")
|
||||||
|
return 0
|
||||||
|
|
||||||
|
|
||||||
|
if __name__ == "__main__":
|
||||||
|
sys.exit(main())
|
||||||
65
install.sh
Executable file
65
install.sh
Executable file
|
|
@ -0,0 +1,65 @@
|
||||||
|
#!/usr/bin/env bash
|
||||||
|
# Instalador del nucleo de JARVIS. Prepara el entorno de Python, el modelo de
|
||||||
|
# Ollama y comprueba los servicios externos. No descarga modelos pesados ni
|
||||||
|
# toca el sistema sin avisar.
|
||||||
|
set -uo pipefail
|
||||||
|
|
||||||
|
AQUI=$(cd -P "$(dirname "${BASH_SOURCE[0]:-$0}")" && pwd)
|
||||||
|
cd "$AQUI"
|
||||||
|
|
||||||
|
ok() { printf ' \033[32mok\033[0m %s\n' "$*"; }
|
||||||
|
falta(){ printf ' \033[33mfalta\033[0m %s\n' "$*"; }
|
||||||
|
malo() { printf ' \033[31mERROR\033[0m %s\n' "$*"; }
|
||||||
|
|
||||||
|
echo "JARVIS — instalacion"
|
||||||
|
echo
|
||||||
|
|
||||||
|
# ── 1. Servicios externos (los instala el usuario; aqui solo se comprueban) ──
|
||||||
|
echo "1. Servicios externos"
|
||||||
|
command -v python3 >/dev/null && ok "python3 $(python3 -V 2>&1 | awk '{print $2}')" \
|
||||||
|
|| { malo "python3 no esta"; exit 1; }
|
||||||
|
command -v ollama >/dev/null && ok "ollama" \
|
||||||
|
|| falta "ollama — instalalo desde https://ollama.com (es el cerebro)"
|
||||||
|
command -v whisper-server >/dev/null && ok "whisper-server (STT)" \
|
||||||
|
|| falta "whisper.cpp con CUDA — compilalo; ver config/README_whisper_gpu.md"
|
||||||
|
command -v piper >/dev/null && ok "piper (TTS)" \
|
||||||
|
|| falta "piper — https://github.com/rhasspy/piper (la voz)"
|
||||||
|
echo
|
||||||
|
|
||||||
|
# ── 2. Entorno de Python del nucleo ─────────────────────────────────────────
|
||||||
|
echo "2. Entorno de Python"
|
||||||
|
if [ ! -d nucleo/venv ]; then
|
||||||
|
python3 -m venv nucleo/venv && ok "creado nucleo/venv"
|
||||||
|
else
|
||||||
|
ok "nucleo/venv ya existe"
|
||||||
|
fi
|
||||||
|
nucleo/venv/bin/pip install -q --upgrade pip >/dev/null 2>&1
|
||||||
|
if nucleo/venv/bin/pip install -q -r requirements.txt; then
|
||||||
|
ok "dependencias instaladas"
|
||||||
|
else
|
||||||
|
malo "fallo instalando dependencias (ver requirements.txt)"; exit 1
|
||||||
|
fi
|
||||||
|
echo
|
||||||
|
|
||||||
|
# ── 3. El modelo de Ollama ──────────────────────────────────────────────────
|
||||||
|
echo "3. El modelo"
|
||||||
|
if command -v ollama >/dev/null; then
|
||||||
|
if ollama list 2>/dev/null | grep -q '^qwen3.5:4b-jarvis'; then
|
||||||
|
ok "qwen3.5:4b-jarvis ya existe"
|
||||||
|
else
|
||||||
|
echo " creando qwen3.5:4b-jarvis (necesita qwen3.5:4b en Ollama)..."
|
||||||
|
if ollama create qwen3.5:4b-jarvis -f config/qwen3.5-4b-jarvis.Modelfile 2>/dev/null; then
|
||||||
|
ok "modelo creado"
|
||||||
|
else
|
||||||
|
falta "no se pudo crear; baja el base con: ollama pull qwen3.5:4b"
|
||||||
|
fi
|
||||||
|
fi
|
||||||
|
else
|
||||||
|
falta "sin ollama no hay modelo; instalalo y re-ejecuta"
|
||||||
|
fi
|
||||||
|
echo
|
||||||
|
|
||||||
|
# ── 4. Siguiente paso ───────────────────────────────────────────────────────
|
||||||
|
echo "Hecho. Para arrancar:"
|
||||||
|
echo " ./nucleo/saber/indexa.py # (opcional) indexa tus apuntes para el RAG"
|
||||||
|
echo " ./nucleo/arranca.sh # el asistente y el panel en 127.0.0.1"
|
||||||
49
jarvis-icon.svg
Normal file
49
jarvis-icon.svg
Normal file
|
|
@ -0,0 +1,49 @@
|
||||||
|
<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 256 256" width="256" height="256">
|
||||||
|
<defs>
|
||||||
|
<radialGradient id="core" cx="50%" cy="50%" r="50%">
|
||||||
|
<stop offset="0%" stop-color="#eafcff"/>
|
||||||
|
<stop offset="45%" stop-color="#7fe9ff"/>
|
||||||
|
<stop offset="100%" stop-color="#1b9fd8"/>
|
||||||
|
</radialGradient>
|
||||||
|
<radialGradient id="halo" cx="50%" cy="50%" r="50%">
|
||||||
|
<stop offset="0%" stop-color="#4fd8ff" stop-opacity=".55"/>
|
||||||
|
<stop offset="70%" stop-color="#1b9fd8" stop-opacity=".12"/>
|
||||||
|
<stop offset="100%" stop-color="#0b3d5c" stop-opacity="0"/>
|
||||||
|
</radialGradient>
|
||||||
|
<linearGradient id="ring" x1="0" y1="0" x2="0" y2="1">
|
||||||
|
<stop offset="0%" stop-color="#cfe9f5"/>
|
||||||
|
<stop offset="100%" stop-color="#5a7f92"/>
|
||||||
|
</linearGradient>
|
||||||
|
</defs>
|
||||||
|
|
||||||
|
<circle cx="128" cy="128" r="124" fill="#0a1620"/>
|
||||||
|
<circle cx="128" cy="128" r="120" fill="url(#halo)"/>
|
||||||
|
|
||||||
|
<!-- carcasa exterior -->
|
||||||
|
<circle cx="128" cy="128" r="106" fill="none" stroke="url(#ring)" stroke-width="9"/>
|
||||||
|
<circle cx="128" cy="128" r="94" fill="none" stroke="#12303f" stroke-width="7"/>
|
||||||
|
|
||||||
|
<!-- bobinas -->
|
||||||
|
<g stroke="#8fd7ef" stroke-width="7" stroke-linecap="round" opacity=".9">
|
||||||
|
<line x1="128" y1="42" x2="128" y2="70"/>
|
||||||
|
<line x1="128" y1="186" x2="128" y2="214"/>
|
||||||
|
<line x1="42" y1="128" x2="70" y2="128"/>
|
||||||
|
<line x1="186" y1="128" x2="214" y2="128"/>
|
||||||
|
<line x1="67" y1="67" x2="87" y2="87"/>
|
||||||
|
<line x1="169" y1="169" x2="189" y2="189"/>
|
||||||
|
<line x1="189" y1="67" x2="169" y2="87"/>
|
||||||
|
<line x1="87" y1="169" x2="67" y2="189"/>
|
||||||
|
</g>
|
||||||
|
|
||||||
|
<!-- anillo interior -->
|
||||||
|
<circle cx="128" cy="128" r="70" fill="none" stroke="#1f5f7d" stroke-width="10"/>
|
||||||
|
<circle cx="128" cy="128" r="58" fill="none" stroke="#4fd8ff" stroke-width="4" opacity=".85"/>
|
||||||
|
|
||||||
|
<!-- triangulo del nucleo -->
|
||||||
|
<path d="M128 84 L166 150 L90 150 Z" fill="none" stroke="#bff0ff" stroke-width="6"
|
||||||
|
stroke-linejoin="round" opacity=".95"/>
|
||||||
|
|
||||||
|
<!-- nucleo -->
|
||||||
|
<circle cx="128" cy="128" r="34" fill="url(#core)"/>
|
||||||
|
<circle cx="128" cy="128" r="16" fill="#ffffff" opacity=".92"/>
|
||||||
|
</svg>
|
||||||
|
After Width: | Height: | Size: 2.1 KiB |
188
jarvis-launcher.sh
Executable file
188
jarvis-launcher.sh
Executable file
|
|
@ -0,0 +1,188 @@
|
||||||
|
#!/usr/bin/env bash
|
||||||
|
# JARVIS — lanzador del asistente local (Newelle)
|
||||||
|
#
|
||||||
|
# sin argumentos abre JARVIS a pantalla completa, sin pasar por el chat
|
||||||
|
# --chat abre Newelle normal, con sus pestañas y su historial
|
||||||
|
# --stop la cierra y libera el modelo
|
||||||
|
# --status que corre, con que cerebro y cuanto ocupa
|
||||||
|
#
|
||||||
|
# El lanzador NO decide el motor: lo lee de gsettings (language-model) y se
|
||||||
|
# adapta. Asi no hay que tocarlo cada vez que se cambia de cerebro, que es
|
||||||
|
# justo lo que lo dejo desincronizado antes: precargaba Ollama mientras la
|
||||||
|
# app usaba su llamacpp interno, ocupando 2.9 GB de VRAM para nada.
|
||||||
|
#
|
||||||
|
# Y el MODELO tampoco, por lo mismo. Estaba escrito a mano aqui y volvio a
|
||||||
|
# pasar exactamente lo de antes: al cambiar la app a qwen3.5:4b-jarvis, el
|
||||||
|
# lanzador seguia precargando qwen3.5:4b. Los dos no caben en 3717 MiB, asi
|
||||||
|
# que ollama tenia que descargar uno para cargar el otro con el panel ya
|
||||||
|
# esperando: 6,55 s hasta la primera respuesta contra 3,70 con los dos de
|
||||||
|
# acuerdo. El sintoma no era "va lento", era "no se abre el panel solo".
|
||||||
|
|
||||||
|
set -uo pipefail
|
||||||
|
|
||||||
|
APPID=io.github.qwersyk.Newelle
|
||||||
|
OLLAMA_URL=http://localhost:11434
|
||||||
|
|
||||||
|
# La salida de la app iba entera a /dev/null. Cuando el panel dejo de abrirse,
|
||||||
|
# el traceback que lo explicaba —una linea— no estaba en ningun sitio, y el
|
||||||
|
# fallo se diagnostico dos veces mal antes de mirarlo. Ahora se guarda.
|
||||||
|
# misma idea que en los scripts de voz: la raiz sale de donde vive esto
|
||||||
|
RAIZ=$(cd -P "$(dirname "${BASH_SOURCE[0]:-$0}")" && pwd)
|
||||||
|
REGISTRO=$RAIZ/jarvis-app.log
|
||||||
|
: > "$REGISTRO" 2>/dev/null || REGISTRO=/dev/null
|
||||||
|
GGUF=$HOME/.var/app/$APPID/config/models/custom_models/qwen3.5-4b.gguf
|
||||||
|
|
||||||
|
# Elige rama: //master es la version propia (jarvis-skin, con reactor arc);
|
||||||
|
# //stable es la de Flathub, la red de seguridad.
|
||||||
|
#
|
||||||
|
# El chequeo mira la typelib de Vte en lib/: si un build deja mal el libdir,
|
||||||
|
# la app arranca y muere con "Namespace Vte not available". Asi el icono
|
||||||
|
# nunca abre una version rota, y se pasa solo a la propia cuando este sana.
|
||||||
|
pick_branch() {
|
||||||
|
local base=$HOME/.local/share/flatpak/app/$APPID/x86_64
|
||||||
|
if [ -f "$base/master/active/files/lib/girepository-1.0/Vte-3.91.typelib" ]; then
|
||||||
|
echo "master"
|
||||||
|
else
|
||||||
|
echo "stable"
|
||||||
|
fi
|
||||||
|
}
|
||||||
|
RAMA=$(pick_branch)
|
||||||
|
|
||||||
|
motor() {
|
||||||
|
flatpak run --command=gsettings "$APPID//$RAMA" get "$APPID" language-model 2>/dev/null \
|
||||||
|
| tr -d "'" | tr -d '\n'
|
||||||
|
}
|
||||||
|
|
||||||
|
# El modelo que la app tiene elegido de verdad, leido de sus ajustes. Si no se
|
||||||
|
# puede leer se cae al 4b pelado, que es mejor que precargar algo que no existe.
|
||||||
|
modelo() {
|
||||||
|
flatpak run --command=gsettings "$APPID//$RAMA" get "$APPID" llm-settings 2>/dev/null \
|
||||||
|
| python3 -c "
|
||||||
|
import json, sys
|
||||||
|
s = sys.stdin.read().strip()
|
||||||
|
try:
|
||||||
|
d = json.loads(s[1:-1].replace('\\\\\\\\', '\\\\').replace(\"\\\\'\", \"'\"))
|
||||||
|
print(d.get('ollama', {}).get('model') or 'qwen3.5:4b')
|
||||||
|
except Exception:
|
||||||
|
print('qwen3.5:4b')
|
||||||
|
" 2>/dev/null || echo qwen3.5:4b
|
||||||
|
}
|
||||||
|
MODEL=$(modelo)
|
||||||
|
|
||||||
|
notify() { command -v notify-send >/dev/null && notify-send -i jarvis "JARVIS" "$1"; }
|
||||||
|
|
||||||
|
ollama_up() { curl -s --max-time 2 "$OLLAMA_URL/api/version" >/dev/null 2>&1; }
|
||||||
|
|
||||||
|
app_corriendo() { pgrep -f "bin/newelle" >/dev/null; }
|
||||||
|
|
||||||
|
# El llama-server interno de la app, no el de Ollama: el suyo vive en /app/bin.
|
||||||
|
servidor_interno() { pgrep -f "/app/bin/llama-server" | head -1; }
|
||||||
|
|
||||||
|
case "${1:-start}" in
|
||||||
|
--stop)
|
||||||
|
# flatpak kill y no pkill: el patron "bin/newelle" tambien casa con la
|
||||||
|
# propia linea de comandos cuando esto se invoca desde un bash -c inline,
|
||||||
|
# y el script se mataba a si mismo antes de llegar aqui.
|
||||||
|
flatpak kill "$APPID" 2>/dev/null || pkill -f "bin/newelle" 2>/dev/null
|
||||||
|
if [ "$(motor)" = "ollama" ] && ollama_up; then
|
||||||
|
curl -s "$OLLAMA_URL/api/generate" \
|
||||||
|
-d "{\"model\":\"$MODEL\",\"keep_alive\":0}" >/dev/null 2>&1
|
||||||
|
notify "Detenido, VRAM liberada"
|
||||||
|
else
|
||||||
|
notify "Detenido"
|
||||||
|
fi
|
||||||
|
echo "JARVIS detenido."
|
||||||
|
;;
|
||||||
|
|
||||||
|
--status|--status-notify)
|
||||||
|
MOTOR=$(motor)
|
||||||
|
app_corriendo && S1="app: abierta (//$RAMA)" || S1="app: cerrada"
|
||||||
|
S2="cerebro: ${MOTOR:-?}"
|
||||||
|
|
||||||
|
if [ "$MOTOR" = "ollama" ]; then
|
||||||
|
S3=$(curl -s "$OLLAMA_URL/api/ps" 2>/dev/null \
|
||||||
|
| python3 -c 'import json,sys
|
||||||
|
ms = json.load(sys.stdin).get("models", [])
|
||||||
|
print("\n".join("cargado: %s %.1f GB (%.1f en GPU)"
|
||||||
|
% (m["name"], m.get("size",0)/1e9, m.get("size_vram",0)/1e9) for m in ms)
|
||||||
|
or "sin modelos cargados")' 2>/dev/null)
|
||||||
|
[ -n "$S3" ] || S3="ollama: caido"
|
||||||
|
else
|
||||||
|
PID=$(servidor_interno)
|
||||||
|
if [ -n "$PID" ]; then
|
||||||
|
S3="cargado en RAM ($(awk '/VmRSS/{printf "%.1f GB", $2/1048576}' \
|
||||||
|
"/proc/$PID/status" 2>/dev/null))"
|
||||||
|
else
|
||||||
|
S3="sin modelos cargados"
|
||||||
|
fi
|
||||||
|
fi
|
||||||
|
|
||||||
|
S4=$(nvidia-smi --query-gpu=memory.used,memory.free --format=csv,noheader 2>/dev/null \
|
||||||
|
| sed 's/^/VRAM usada\/libre: /')
|
||||||
|
|
||||||
|
if [ "$1" = "--status-notify" ]; then
|
||||||
|
notify "$S1 · $S2"$'\n'"$S3"$'\n'"$S4"
|
||||||
|
else
|
||||||
|
printf '%s\n%s\n\n%s\n%s\n' "$S1" "$S2" "$S3" "$S4"
|
||||||
|
fi
|
||||||
|
;;
|
||||||
|
|
||||||
|
*)
|
||||||
|
MOTOR=$(motor)
|
||||||
|
|
||||||
|
if [ "$MOTOR" = "ollama" ]; then
|
||||||
|
if ! ollama_up; then
|
||||||
|
systemctl start ollama 2>/dev/null || sudo systemctl start ollama
|
||||||
|
for _ in $(seq 20); do ollama_up && break; sleep 0.5; done
|
||||||
|
fi
|
||||||
|
ollama_up || { notify "Ollama no arranca"; echo "ERROR: ollama no responde" >&2; exit 1; }
|
||||||
|
# precargar en GPU para que la primera respuesta no tarde.
|
||||||
|
# think:false o se va a 40 s pensando en voz alta.
|
||||||
|
curl -s "$OLLAMA_URL/api/generate" \
|
||||||
|
-d "{\"model\":\"$MODEL\",\"prompt\":\"ok\",\"stream\":false,\"think\":false,\"keep_alive\":\"30m\"}" \
|
||||||
|
>/dev/null 2>&1 &
|
||||||
|
else
|
||||||
|
[ -f "$GGUF" ] || { notify "Falta el modelo: $(basename "$GGUF")"
|
||||||
|
echo "ERROR: no esta $GGUF" >&2; exit 1; }
|
||||||
|
fi
|
||||||
|
|
||||||
|
# --chat abre Newelle tal cual; sin argumentos va derecho al asistente
|
||||||
|
DIRECTO=si
|
||||||
|
[ "${1:-}" = "--chat" ] && DIRECTO=no
|
||||||
|
|
||||||
|
if app_corriendo; then
|
||||||
|
command -v xdotool >/dev/null && \
|
||||||
|
xdotool search --name "^newelle$" windowactivate 2>/dev/null
|
||||||
|
elif [ "$DIRECTO" = "no" ]; then
|
||||||
|
exec flatpak run "$APPID//$RAMA"
|
||||||
|
else
|
||||||
|
# En segundo plano y no con exec: hay que esperar a que exista la ventana
|
||||||
|
# antes de pedir la pestaña. --run-action se procesa antes de que la
|
||||||
|
# ventana este construida, asi que lanzarlo de golpe no serviria.
|
||||||
|
#
|
||||||
|
# Y esperar al PROCESO no basta: el proceso existe en cuanto python
|
||||||
|
# arranca, varios segundos antes de que haya ventana. Con `sleep 3` a
|
||||||
|
# ojo, un arranque un poco mas lento pierde la carrera y la accion
|
||||||
|
# revienta con "'MyApp' object has no attribute 'win'" — la app abre,
|
||||||
|
# pero en el chat y sin panel. Se espera a la VENTANA, que es la
|
||||||
|
# condicion de verdad.
|
||||||
|
flatpak run "$APPID//$RAMA" >>"$REGISTRO" 2>&1 &
|
||||||
|
for _ in $(seq 60); do
|
||||||
|
if command -v xdotool >/dev/null; then
|
||||||
|
xdotool search --name "^newelle$" >/dev/null 2>&1 && break
|
||||||
|
else
|
||||||
|
pgrep -f "bin/newelle" >/dev/null && break
|
||||||
|
fi
|
||||||
|
sleep 0.5
|
||||||
|
done
|
||||||
|
# sin xdotool no hay forma de saberlo: se vuelve al margen a ojo
|
||||||
|
command -v xdotool >/dev/null || sleep 3
|
||||||
|
fi
|
||||||
|
|
||||||
|
if [ "$DIRECTO" = "si" ]; then
|
||||||
|
# jarvis_full y no jarvis+hud: el segundo alterna, asi que pulsar el
|
||||||
|
# icono con la app ya abierta te sacaria de pantalla completa.
|
||||||
|
flatpak run "$APPID//$RAMA" --run-action=jarvis_full >>"$REGISTRO" 2>&1
|
||||||
|
fi
|
||||||
|
;;
|
||||||
|
esac
|
||||||
6
nucleo/.gitignore
vendored
Normal file
6
nucleo/.gitignore
vendored
Normal file
|
|
@ -0,0 +1,6 @@
|
||||||
|
datos/cache_voz/
|
||||||
|
venv/
|
||||||
|
__pycache__/
|
||||||
|
*.pyc
|
||||||
|
datos/saber.jsonl
|
||||||
|
datos/diario.jsonl
|
||||||
135
nucleo/arranca.sh
Executable file
135
nucleo/arranca.sh
Executable file
|
|
@ -0,0 +1,135 @@
|
||||||
|
#!/usr/bin/env bash
|
||||||
|
# Lanzador del JARVIS naranja: el nucleo, fuera del flatpak.
|
||||||
|
#
|
||||||
|
# arranca.sh levanta ollama si hace falta, abre el panel y escucha
|
||||||
|
# arranca.sh --panel solo el panel, sin microfono
|
||||||
|
# arranca.sh --stop lo para y libera la grafica
|
||||||
|
# arranca.sh --estado dice si esta vivo
|
||||||
|
#
|
||||||
|
# Comparado con el lanzador del JARVIS azul, aqui sobra casi todo: no hay que
|
||||||
|
# adivinar la rama del flatpak, ni leer gsettings con escapado de GVariant, ni
|
||||||
|
# preguntarle a la aplicacion que modelo tiene puesto. El nucleo lo sabe porque
|
||||||
|
# es suyo.
|
||||||
|
#
|
||||||
|
# Lo que SI se conserva, porque en esta maquina importa: al parar se le dice a
|
||||||
|
# ollama que suelte el modelo. Son 2,1 GB de una tarjeta de 4, y sin esto whisper
|
||||||
|
# se queda sin sitio la proxima vez.
|
||||||
|
set -uo pipefail
|
||||||
|
|
||||||
|
RAIZ=$(cd -P "$(dirname "${BASH_SOURCE[0]:-$0}")" && pwd)
|
||||||
|
PYTHON=$RAIZ/venv/bin/python
|
||||||
|
[ -x "$PYTHON" ] || PYTHON=$(command -v python3)
|
||||||
|
OLLAMA_URL=${JARVIS_OLLAMA:-http://127.0.0.1:11434}
|
||||||
|
REGISTRO=$RAIZ/jarvis.log
|
||||||
|
PUERTO=${JARVIS_PUERTO:-8790}
|
||||||
|
|
||||||
|
# Fichero de PID, no pgrep.
|
||||||
|
#
|
||||||
|
# El primer intento fue marcar el proceso con una variable de entorno y buscarla
|
||||||
|
# con `pgrep -f`. No funciona: pgrep mira la LINEA DE ORDENES, y `env VAR=1 cmd`
|
||||||
|
# no deja la variable ahi. El sintoma fue peor que un simple "no lo encuentra":
|
||||||
|
# el lanzador creia que no habia nada corriendo, arrancaba un segundo, y ese
|
||||||
|
# moria con "address already in use" mientras el primero seguia vivo.
|
||||||
|
#
|
||||||
|
# Y buscar por el nombre del script tiene el problema de siempre: el patron
|
||||||
|
# aparece en la linea de ordenes del propio pgrep. Un fichero de PID no se
|
||||||
|
# equivoca.
|
||||||
|
PID=${XDG_RUNTIME_DIR:-/tmp}/jarvis-nucleo.pid
|
||||||
|
|
||||||
|
aviso() { command -v notify-send >/dev/null && \
|
||||||
|
notify-send -i "$RAIZ/jarvis-naranja.svg" "JARVIS" "$1"; }
|
||||||
|
|
||||||
|
modelo() {
|
||||||
|
grep -oP 'MODELO = os\.environ\.get\("JARVIS_MODELO", "\K[^"]+' \
|
||||||
|
"$RAIZ/cerebro/ollama.py" 2>/dev/null || echo "qwen3.5:4b-jarvis"
|
||||||
|
}
|
||||||
|
|
||||||
|
# Vivo = hay un pid apuntado Y ese proceso existe. Un pid huerfano de un
|
||||||
|
# reinicio no puede hacernos creer que sigue en marcha.
|
||||||
|
vivo() {
|
||||||
|
[ -f "$PID" ] || return 1
|
||||||
|
local p; p=$(cat "$PID" 2>/dev/null)
|
||||||
|
[ -n "$p" ] && kill -0 "$p" 2>/dev/null
|
||||||
|
}
|
||||||
|
ollama_up() { curl -s --max-time 2 "$OLLAMA_URL/api/version" >/dev/null 2>&1; }
|
||||||
|
puerto_ocupado() { curl -s --max-time 2 "http://127.0.0.1:$PUERTO/" >/dev/null 2>&1; }
|
||||||
|
|
||||||
|
case "${1:-arranca}" in
|
||||||
|
--stop)
|
||||||
|
# Tambien lo que este ocupando el puerto sin fichero de pid: si no, un
|
||||||
|
# huerfano impide arrancar de nuevo y --stop parece no hacer nada.
|
||||||
|
if ! vivo && puerto_ocupado && command -v fuser >/dev/null; then
|
||||||
|
fuser -k "$PUERTO/tcp" >/dev/null 2>&1
|
||||||
|
fi
|
||||||
|
if vivo; then
|
||||||
|
kill "$(cat "$PID")" 2>/dev/null
|
||||||
|
# margen para que suelte el puerto antes de que nadie lo reclame
|
||||||
|
for _ in 1 2 3 4 5 6 7 8 9 10; do vivo || break; sleep 0.3; done
|
||||||
|
vivo && kill -9 "$(cat "$PID")" 2>/dev/null
|
||||||
|
fi
|
||||||
|
rm -f "$PID"
|
||||||
|
if ollama_up; then
|
||||||
|
# keep_alive 0: suelta el modelo ya, no dentro de cinco minutos
|
||||||
|
curl -s "$OLLAMA_URL/api/generate" \
|
||||||
|
-d "{\"model\":\"$(modelo)\",\"keep_alive\":0}" >/dev/null 2>&1
|
||||||
|
aviso "Detenido, grafica liberada"
|
||||||
|
else
|
||||||
|
aviso "Detenido"
|
||||||
|
fi
|
||||||
|
exit 0
|
||||||
|
;;
|
||||||
|
|
||||||
|
--estado)
|
||||||
|
# Se mira el pid Y el puerto. Con solo el pid, una instancia arrancada a
|
||||||
|
# mano —o superviviente de un lanzador que murio— daba "parado" mientras
|
||||||
|
# el panel contestaba tan tranquilo, que es la peor respuesta posible:
|
||||||
|
# la que hace dudar de si el problema es el programa o quien pregunta.
|
||||||
|
if vivo; then
|
||||||
|
echo "JARVIS naranja: vivo"
|
||||||
|
exit 0
|
||||||
|
fi
|
||||||
|
if puerto_ocupado; then
|
||||||
|
echo "JARVIS naranja: vivo, pero arrancado por fuera de este lanzador"
|
||||||
|
echo " (no hay $PID; para pararlo: fuser -k $PUERTO/tcp)"
|
||||||
|
exit 0
|
||||||
|
fi
|
||||||
|
echo "JARVIS naranja: parado"
|
||||||
|
exit 1
|
||||||
|
;;
|
||||||
|
esac
|
||||||
|
|
||||||
|
if vivo || puerto_ocupado; then
|
||||||
|
# Ya esta abierto: en vez de levantar otro —que moriria con "address already
|
||||||
|
# in use" y dejaria un rastro confuso— se trae el panel al frente.
|
||||||
|
aviso "Ya estaba en marcha"
|
||||||
|
# La MISMA ventana que abre el arranque normal. Antes esto era xdg-open, que
|
||||||
|
# abre el navegador POR DEFECTO en una pestaña: segun si JARVIS ya estaba
|
||||||
|
# abierto o no, el mismo icono daba una aplicacion o una pestaña de Firefox.
|
||||||
|
setsid "$RAIZ/ventana.sh" "http://127.0.0.1:$PUERTO/" >/dev/null 2>&1 &
|
||||||
|
exit 0
|
||||||
|
fi
|
||||||
|
|
||||||
|
# ollama, si no esta ya. En segundo plano y sin esperar: el catalogo contesta
|
||||||
|
# las ordenes conocidas sin tocar el modelo, asi que JARVIS es util desde el
|
||||||
|
# primer segundo aunque ollama tarde en calentar.
|
||||||
|
if ! ollama_up && command -v ollama >/dev/null; then
|
||||||
|
setsid ollama serve >/dev/null 2>&1 &
|
||||||
|
fi
|
||||||
|
|
||||||
|
# El indice de COFRE, si no esta. En segundo plano: JARVIS arranca sin el y el
|
||||||
|
# cerebro lo usa en cuanto este listo. Reconstruirlo a mano: saber/indexa.py
|
||||||
|
if [ ! -f "$RAIZ/datos/saber.jsonl" ]; then
|
||||||
|
setsid "$PYTHON" "$RAIZ/saber/indexa.py" >/dev/null 2>&1 &
|
||||||
|
fi
|
||||||
|
|
||||||
|
: > "$REGISTRO" 2>/dev/null || REGISTRO=/dev/null
|
||||||
|
aviso "Arrancando"
|
||||||
|
|
||||||
|
MODO=(--panel --escucha)
|
||||||
|
[ "${1:-}" = "--panel" ] && MODO=(--panel)
|
||||||
|
|
||||||
|
# El pid se apunta ANTES del exec y es el de este mismo shell, que con exec
|
||||||
|
# pasa a ser el de Python: asi el fichero nunca apunta a un proceso que no es.
|
||||||
|
echo $$ > "$PID"
|
||||||
|
trap 'rm -f "$PID"' EXIT
|
||||||
|
exec "$PYTHON" -u "$RAIZ/jarvis.py" "${MODO[@]}" >>"$REGISTRO" 2>&1
|
||||||
0
nucleo/boca/__init__.py
Normal file
0
nucleo/boca/__init__.py
Normal file
210
nucleo/boca/voz.py
Normal file
210
nucleo/boca/voz.py
Normal file
|
|
@ -0,0 +1,210 @@
|
||||||
|
"""La boca de JARVIS: convertir texto en sonido, y saber cuando esta sonando.
|
||||||
|
|
||||||
|
Esto es la version de `voces.py` + la mitad de `tts.py` de Newelle, pero sin el
|
||||||
|
motor de handlers: aqui solo hablamos por Piper y por el clon, y los dos son un
|
||||||
|
script de shell que escribe un WAV. Todo lo demas sobraba.
|
||||||
|
|
||||||
|
## Lo que hay que hacer bien y en Newelle estaba mal
|
||||||
|
|
||||||
|
**Saber que esta hablando, y saberlo A TIEMPO.** El eco que envenena el registro
|
||||||
|
de JARVIS —el 21 % confirmado de las frases que no entiende son suyas— viene de
|
||||||
|
que Newelle marca `assistant_speaking` con `GLib.idle_add`, que es asincrono: el
|
||||||
|
audio ya esta sonando mientras el hilo de grabacion sigue leyendo `False`. Aqui
|
||||||
|
la bandera se pone ANTES de lanzar el reproductor y se quita con retardo, porque
|
||||||
|
cuando el proceso termina el sonido todavia esta viajando hasta el microfono.
|
||||||
|
|
||||||
|
**Un solo altavoz.** Con tareas en paralelo, dos respuestas a la vez se pisan.
|
||||||
|
Se habla por turnos con un cerrojo, igual que hacia `_habla` en el panel.
|
||||||
|
|
||||||
|
## La cache
|
||||||
|
|
||||||
|
Clave `sha1(voz|texto normalizado)`. Piper tarda entre medio segundo y dos por
|
||||||
|
frase, y JARVIS repite mucho ("Enseguida, señor", "No he podido, señor"): con
|
||||||
|
cache eso es un `cp`.
|
||||||
|
|
||||||
|
Se guarda en `datos/cache_voz/`, no en la del clon: aquella la genera
|
||||||
|
`generar_cache_voz.py` con su propia clave (sha1 solo del texto) y es de solo
|
||||||
|
lectura para nosotros. `jarvis-voz.sh` ya la consulta por dentro.
|
||||||
|
"""
|
||||||
|
import hashlib
|
||||||
|
import os
|
||||||
|
import re
|
||||||
|
import shutil
|
||||||
|
import subprocess
|
||||||
|
import threading
|
||||||
|
import time
|
||||||
|
|
||||||
|
RAIZ = os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
|
||||||
|
CONFIG = os.path.join(RAIZ, "config")
|
||||||
|
MODELOS = os.path.join(RAIZ, "voz", "modelos")
|
||||||
|
CACHE = os.path.join(os.path.dirname(os.path.dirname(os.path.abspath(__file__))),
|
||||||
|
"datos", "cache_voz")
|
||||||
|
|
||||||
|
# Cuanto se sigue considerando "hablando" despues de que el reproductor termine.
|
||||||
|
# El sonido tarda en salir del buffer de la tarjeta y en llegar al microfono; sin
|
||||||
|
# esta cola, la ultima silaba de JARVIS se cuela en la siguiente transcripcion.
|
||||||
|
#
|
||||||
|
# El valor sale de medirlo con pruebas/prueba_eco.py, no de suponerlo: con 350
|
||||||
|
# la frase entera dejaba de colarse pero seguia escapandose un fragmento.
|
||||||
|
COLA_MS = int(os.environ.get("JARVIS_COLA_MS", "700"))
|
||||||
|
|
||||||
|
|
||||||
|
def _piper(modelo):
|
||||||
|
return {
|
||||||
|
"orden": [os.path.join(CONFIG, "jarvis-piper.sh")],
|
||||||
|
"entorno": {"JARVIS_PIPER_VOZ": modelo, "JARVIS_PIPER_TONO": "1.0"},
|
||||||
|
"necesita": os.path.join(MODELOS, modelo + ".onnx"),
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
# El orden es el de rotacion. davefx primero porque es la que se eligio a oido.
|
||||||
|
VOCES = {
|
||||||
|
"davefx": _piper("es_ES-davefx-medium"),
|
||||||
|
"clon": {
|
||||||
|
"orden": [os.path.join(CONFIG, "jarvis-voz.sh")],
|
||||||
|
"entorno": {},
|
||||||
|
"necesita": os.path.join(CONFIG, "jarvis-voz.sh"),
|
||||||
|
},
|
||||||
|
"claude": _piper("es_MX-claude-high"),
|
||||||
|
"ald": _piper("es_MX-ald-medium"),
|
||||||
|
"sharvard": _piper("es_ES-sharvard-medium"),
|
||||||
|
}
|
||||||
|
|
||||||
|
POR_DEFECTO = "davefx"
|
||||||
|
|
||||||
|
# Se prueban en orden. paplay y pw-play respetan el enrutado de PipeWire, que es
|
||||||
|
# lo que hace falta para que el cancelador de eco tenga la referencia de lo que
|
||||||
|
# sale por los altavoces. aplay habla con ALSA directamente y se la salta.
|
||||||
|
REPRODUCTORES = (["paplay"], ["pw-play"], ["aplay", "-q"])
|
||||||
|
|
||||||
|
|
||||||
|
def _normaliza(texto: str) -> str:
|
||||||
|
return re.sub(r"\s+", " ", texto or "").strip()
|
||||||
|
|
||||||
|
|
||||||
|
def _clave(voz: str, texto: str) -> str:
|
||||||
|
return hashlib.sha1(f"{voz}|{_normaliza(texto)}".encode()).hexdigest()[:16]
|
||||||
|
|
||||||
|
|
||||||
|
def _reproductor():
|
||||||
|
for r in REPRODUCTORES:
|
||||||
|
if shutil.which(r[0]):
|
||||||
|
return r
|
||||||
|
return None
|
||||||
|
|
||||||
|
|
||||||
|
class Boca:
|
||||||
|
"""Todo lo que suena sale de aqui, y de uno en uno."""
|
||||||
|
|
||||||
|
def __init__(self, voz: str = POR_DEFECTO, al_cambiar=None):
|
||||||
|
self.voz = voz if voz in VOCES else POR_DEFECTO
|
||||||
|
self._turno = threading.Lock()
|
||||||
|
self._hablando = False
|
||||||
|
self._hasta = 0.0 # instante hasta el que sigue contando como hablando
|
||||||
|
self._al_cambiar = al_cambiar # se avisa al oido para que se calle
|
||||||
|
os.makedirs(CACHE, exist_ok=True)
|
||||||
|
|
||||||
|
# ------------------------------------------------------------ el estado
|
||||||
|
|
||||||
|
@property
|
||||||
|
def hablando(self) -> bool:
|
||||||
|
"""Si esta sonando algo, incluida la cola.
|
||||||
|
|
||||||
|
El oido consulta esto en cada trozo de audio. Tiene que ser barato y,
|
||||||
|
sobre todo, no puede mentir por defecto: mas vale sobrar 300 ms de
|
||||||
|
silencio que colar la propia voz en la transcripcion.
|
||||||
|
"""
|
||||||
|
return self._hablando or time.monotonic() < self._hasta
|
||||||
|
|
||||||
|
def _marca(self, hablando: bool):
|
||||||
|
self._hablando = hablando
|
||||||
|
if not hablando:
|
||||||
|
self._hasta = time.monotonic() + COLA_MS / 1000.0
|
||||||
|
if self._al_cambiar:
|
||||||
|
try:
|
||||||
|
self._al_cambiar(hablando)
|
||||||
|
except Exception:
|
||||||
|
pass
|
||||||
|
|
||||||
|
# ------------------------------------------------------------- generar
|
||||||
|
|
||||||
|
def _genera(self, texto: str) -> str | None:
|
||||||
|
"""Devuelve la ruta del WAV, de cache o recien hecho."""
|
||||||
|
voz = VOCES[self.voz]
|
||||||
|
destino = os.path.join(CACHE, _clave(self.voz, texto) + ".wav")
|
||||||
|
if os.path.exists(destino) and os.path.getsize(destino) > 0:
|
||||||
|
return destino
|
||||||
|
|
||||||
|
entorno = {**os.environ, **voz["entorno"]}
|
||||||
|
try:
|
||||||
|
subprocess.run(voz["orden"] + [destino, texto], env=entorno,
|
||||||
|
capture_output=True, timeout=120)
|
||||||
|
except (subprocess.TimeoutExpired, OSError):
|
||||||
|
return None
|
||||||
|
if not os.path.exists(destino) or os.path.getsize(destino) == 0:
|
||||||
|
# Que no se quede un fichero vacio en la cache: el siguiente intento
|
||||||
|
# lo daria por bueno y JARVIS se quedaria mudo para esa frase.
|
||||||
|
if os.path.exists(destino):
|
||||||
|
os.unlink(destino)
|
||||||
|
return None
|
||||||
|
return destino
|
||||||
|
|
||||||
|
# -------------------------------------------------------------- hablar
|
||||||
|
|
||||||
|
def di(self, texto: str) -> bool:
|
||||||
|
"""Habla, esperando turno. Devuelve si sono."""
|
||||||
|
texto = _normaliza(texto)
|
||||||
|
if not texto:
|
||||||
|
return False
|
||||||
|
with self._turno:
|
||||||
|
return self._suelta(texto)
|
||||||
|
|
||||||
|
def di_si_libre(self, texto: str) -> bool:
|
||||||
|
"""Habla solo si nadie tiene el turno. Para avisos que no merecen cola."""
|
||||||
|
if not self._turno.acquire(blocking=False):
|
||||||
|
return False
|
||||||
|
try:
|
||||||
|
return self._suelta(_normaliza(texto))
|
||||||
|
finally:
|
||||||
|
self._turno.release()
|
||||||
|
|
||||||
|
def _suelta(self, texto: str) -> bool:
|
||||||
|
wav = self._genera(texto)
|
||||||
|
if not wav:
|
||||||
|
return False
|
||||||
|
orden = _reproductor()
|
||||||
|
if not orden:
|
||||||
|
return False
|
||||||
|
|
||||||
|
# La bandera ANTES de lanzar el reproductor, no despues y no en otro
|
||||||
|
# hilo. Este es exactamente el fallo de Newelle que causa el eco.
|
||||||
|
self._marca(True)
|
||||||
|
try:
|
||||||
|
subprocess.run(orden + [wav], capture_output=True, timeout=300)
|
||||||
|
except (subprocess.TimeoutExpired, OSError):
|
||||||
|
return False
|
||||||
|
finally:
|
||||||
|
self._marca(False)
|
||||||
|
return True
|
||||||
|
|
||||||
|
# --------------------------------------------------------------- voces
|
||||||
|
|
||||||
|
def disponibles(self) -> list:
|
||||||
|
return [n for n, v in VOCES.items() if os.path.exists(v["necesita"])]
|
||||||
|
|
||||||
|
def cambia(self, nombre: str) -> bool:
|
||||||
|
if nombre not in VOCES or not os.path.exists(VOCES[nombre]["necesita"]):
|
||||||
|
return False
|
||||||
|
self.voz = nombre
|
||||||
|
return True
|
||||||
|
|
||||||
|
def siguiente(self) -> str:
|
||||||
|
lista = self.disponibles()
|
||||||
|
if not lista:
|
||||||
|
return self.voz
|
||||||
|
try:
|
||||||
|
i = lista.index(self.voz)
|
||||||
|
except ValueError:
|
||||||
|
i = -1
|
||||||
|
self.voz = lista[(i + 1) % len(lista)]
|
||||||
|
return self.voz
|
||||||
0
nucleo/cara/__init__.py
Normal file
0
nucleo/cara/__init__.py
Normal file
948
nucleo/cara/hud/hud.js
Normal file
948
nucleo/cara/hud/hud.js
Normal file
|
|
@ -0,0 +1,948 @@
|
||||||
|
/* HUD de JARVIS.
|
||||||
|
*
|
||||||
|
* Python empuja eventos con window.jarvis.recibe({tipo, datos}) y el HUD
|
||||||
|
* devuelve pulsaciones por window.webkit.messageHandlers.
|
||||||
|
*
|
||||||
|
* Los niveles llegan a ~15 por segundo para no cargar el puente; el dibujo
|
||||||
|
* va a 60 con requestAnimationFrame e interpola entre envios, asi que se ve
|
||||||
|
* fluido sin pagarlo en llamadas. */
|
||||||
|
|
||||||
|
(() => {
|
||||||
|
"use strict";
|
||||||
|
|
||||||
|
const BANDAS = 12;
|
||||||
|
const MAX_ACCIONES = 8;
|
||||||
|
|
||||||
|
// El reactor no lleva colores propios: los lee de las variables del CSS, asi
|
||||||
|
// que cambiar la paleta repinta tambien el canvas sin tocar JavaScript. Un
|
||||||
|
// solo tema —naranja neon sobre negro— y por eso ya no hay lista ni rotacion.
|
||||||
|
const VARIABLES = {
|
||||||
|
reposo: ["--r-vivo", "--r-hondo", "--r-nucleo"],
|
||||||
|
escuchando: ["--r-vivo", "--r-hondo", "--r-nucleo"],
|
||||||
|
hablando: ["--r-habla", "--r-habla-hondo", "--r-habla-nucleo"],
|
||||||
|
parado: ["--r-parado", "--r-parado-hondo", "--r-parado-nucleo"],
|
||||||
|
};
|
||||||
|
|
||||||
|
let COLORES = {};
|
||||||
|
|
||||||
|
function leeColores() {
|
||||||
|
const css = getComputedStyle(document.documentElement);
|
||||||
|
COLORES = {};
|
||||||
|
for (const [estado, vars] of Object.entries(VARIABLES)) {
|
||||||
|
const [vivo, hondo, nucleo] = vars.map((v) => css.getPropertyValue(v).trim());
|
||||||
|
COLORES[estado] = { vivo, hondo, nucleo };
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
// La lista de voces vive en Python (utility/voces.py), no aqui: el boton solo
|
||||||
|
// pide "la siguiente" y pinta lo que le contesten. Asi el rotulo no puede
|
||||||
|
// decir una voz distinta de la que esta puesta de verdad.
|
||||||
|
function ponVoz(datos) {
|
||||||
|
const boton = document.getElementById("voz");
|
||||||
|
if (!boton || !datos) return;
|
||||||
|
boton.querySelector(".rotulo").textContent = "voz: " + (datos.nombre || "?");
|
||||||
|
boton.dataset.voz = datos.id || "";
|
||||||
|
// el motivo del fallo se lee al pasar por encima, no ocupa sitio en pantalla
|
||||||
|
boton.title = datos.error
|
||||||
|
? "No pude cambiar de voz: " + datos.error
|
||||||
|
: "Cambiar la voz. La estrena diciendo una frase";
|
||||||
|
boton.classList.toggle("fallo", Boolean(datos.error));
|
||||||
|
}
|
||||||
|
|
||||||
|
// Igual que la voz: la lista vive en Python (utility/cerebro.py). Pero este
|
||||||
|
// boton marca ademas si lo que se dice SALE de la maquina, porque eso no se
|
||||||
|
// puede saber mirando el panel de ninguna otra forma.
|
||||||
|
function ponCerebro(datos) {
|
||||||
|
const boton = document.getElementById("cerebro");
|
||||||
|
if (!boton || !datos) return;
|
||||||
|
boton.querySelector(".rotulo").textContent = "cerebro: " + (datos.nombre || "?");
|
||||||
|
boton.dataset.cerebro = datos.id || "";
|
||||||
|
boton.classList.toggle("fuera", Boolean(datos.fuera));
|
||||||
|
boton.classList.toggle("fallo", Boolean(datos.error));
|
||||||
|
boton.title = datos.error
|
||||||
|
? "No pude cambiar de cerebro: " + datos.error
|
||||||
|
: (datos.fuera
|
||||||
|
? "Piensa con Claude (" + (datos.detalle || "") + "). La voz sigue "
|
||||||
|
+ "siendo local, pero lo que preguntes sale de esta maquina."
|
||||||
|
: "Piensa aqui dentro (" + (datos.detalle || "") + "). Nada sale de "
|
||||||
|
+ "la maquina.");
|
||||||
|
if (datos.nombre && datos.nombre !== "\u2014") {
|
||||||
|
aConsola("cerebro: " + datos.nombre
|
||||||
|
+ (datos.fuera ? " (las preguntas salen de la maquina)"
|
||||||
|
: " (todo local)"), "orden");
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
function ponDicho(texto, atendido, motivo) {
|
||||||
|
elDicho.textContent = texto || "";
|
||||||
|
elDicho.classList.toggle("visible", Boolean(texto));
|
||||||
|
elDicho.classList.toggle("desoido", !atendido);
|
||||||
|
elDicho.dataset.motivo = atendido ? "" : (motivo || "");
|
||||||
|
}
|
||||||
|
|
||||||
|
// La conversacion tambien va a la consola. Bajo el reactor solo se ve la
|
||||||
|
// ultima frase; aqui queda el hilo entero con su hora, que es lo que hace
|
||||||
|
// falta para entender por que no reacciono hace dos minutos.
|
||||||
|
function aConsolaDicho(texto, atendido, motivo) {
|
||||||
|
if (!texto) return;
|
||||||
|
if (atendido) {
|
||||||
|
aConsola("> " + texto, "orden");
|
||||||
|
} else {
|
||||||
|
aConsola("> " + texto, "malo");
|
||||||
|
if (motivo) aConsola(" " + motivo, "malo");
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
const ETIQUETAS = {
|
||||||
|
reposo: "en reposo",
|
||||||
|
// "escuchando" prometia mas de lo que hacia: el microfono esta abierto,
|
||||||
|
// pero mientras no se le llame por su nombre no atiende nada. Decirlo evita
|
||||||
|
// la duda de si el problema es el microfono.
|
||||||
|
dormido: "diga jarvis",
|
||||||
|
escuchando: "escuchando",
|
||||||
|
pensando: "pensando",
|
||||||
|
preguntando: "conteste",
|
||||||
|
hablando: "respondiendo",
|
||||||
|
parado: "desconectado",
|
||||||
|
};
|
||||||
|
|
||||||
|
const nivelesObjetivo = new Array(BANDAS).fill(0.04);
|
||||||
|
const nivelesActuales = new Array(BANDAS).fill(0.04);
|
||||||
|
let estado = "parado";
|
||||||
|
let fase = 0;
|
||||||
|
|
||||||
|
const lienzo = document.getElementById("reactor");
|
||||||
|
const ctx = lienzo.getContext("2d");
|
||||||
|
const elEstado = document.getElementById("estado");
|
||||||
|
const elDicho = document.getElementById("dicho");
|
||||||
|
const elRegistro = document.getElementById("registro");
|
||||||
|
|
||||||
|
/* ------------------------------------------------------------ dibujo */
|
||||||
|
|
||||||
|
function ajustarLienzo() {
|
||||||
|
const escala = window.devicePixelRatio || 1;
|
||||||
|
const lado = lienzo.clientWidth;
|
||||||
|
lienzo.width = lado * escala;
|
||||||
|
lienzo.height = lado * escala;
|
||||||
|
ctx.setTransform(escala, 0, 0, escala, 0, 0);
|
||||||
|
}
|
||||||
|
|
||||||
|
function dibujar() {
|
||||||
|
const lado = lienzo.clientWidth;
|
||||||
|
const cx = lado / 2;
|
||||||
|
const cy = lado / 2;
|
||||||
|
const color = COLORES[estado] || COLORES.reposo;
|
||||||
|
|
||||||
|
ctx.clearRect(0, 0, lado, lado);
|
||||||
|
|
||||||
|
let media = 0;
|
||||||
|
for (let i = 0; i < BANDAS; i++) {
|
||||||
|
nivelesActuales[i] += (nivelesObjetivo[i] - nivelesActuales[i]) * 0.25;
|
||||||
|
media += nivelesActuales[i];
|
||||||
|
}
|
||||||
|
media /= BANDAS;
|
||||||
|
|
||||||
|
const radioBase = lado * 0.17;
|
||||||
|
const largoMax = lado * 0.20;
|
||||||
|
|
||||||
|
// halo: crece con la voz, da la sensacion de energia sin dibujar nada mas
|
||||||
|
const halo = ctx.createRadialGradient(cx, cy, radioBase * 0.2, cx, cy,
|
||||||
|
radioBase + largoMax * (0.5 + media));
|
||||||
|
halo.addColorStop(0, hexA(color.vivo, 0.20 + media * 0.30));
|
||||||
|
halo.addColorStop(0.55, hexA(color.vivo, 0.06));
|
||||||
|
halo.addColorStop(1, hexA(color.vivo, 0));
|
||||||
|
ctx.fillStyle = halo;
|
||||||
|
ctx.fillRect(0, 0, lado, lado);
|
||||||
|
|
||||||
|
// anillos de fondo, quietos: dan escala a lo que se mueve
|
||||||
|
ctx.strokeStyle = hexA(color.vivo, 0.10);
|
||||||
|
ctx.lineWidth = 1;
|
||||||
|
for (const f of [0.62, 0.82, 1.0]) {
|
||||||
|
ctx.beginPath();
|
||||||
|
ctx.arc(cx, cy, (radioBase + largoMax) * f, 0, Math.PI * 2);
|
||||||
|
ctx.stroke();
|
||||||
|
}
|
||||||
|
|
||||||
|
// espigas: una por banda del analizador
|
||||||
|
ctx.lineCap = "round";
|
||||||
|
for (let i = 0; i < BANDAS; i++) {
|
||||||
|
const ang = (i / BANDAS) * Math.PI * 2 + fase - Math.PI / 2;
|
||||||
|
const nivel = Math.min(1, nivelesActuales[i]);
|
||||||
|
const r0 = radioBase;
|
||||||
|
const r1 = radioBase + largoMax * (0.10 + nivel * 0.9);
|
||||||
|
|
||||||
|
const grad = ctx.createLinearGradient(
|
||||||
|
cx + Math.cos(ang) * r0, cy + Math.sin(ang) * r0,
|
||||||
|
cx + Math.cos(ang) * r1, cy + Math.sin(ang) * r1);
|
||||||
|
grad.addColorStop(0, hexA(color.vivo, 0.95));
|
||||||
|
grad.addColorStop(1, hexA(color.hondo, 0.15));
|
||||||
|
|
||||||
|
ctx.strokeStyle = grad;
|
||||||
|
ctx.lineWidth = Math.max(2, lado * 0.010);
|
||||||
|
ctx.beginPath();
|
||||||
|
ctx.moveTo(cx + Math.cos(ang) * r0, cy + Math.sin(ang) * r0);
|
||||||
|
ctx.lineTo(cx + Math.cos(ang) * r1, cy + Math.sin(ang) * r1);
|
||||||
|
ctx.stroke();
|
||||||
|
}
|
||||||
|
|
||||||
|
// tres arcos girando a distinta velocidad y sentido: nunca parece congelado
|
||||||
|
ctx.lineWidth = Math.max(1.5, lado * 0.005);
|
||||||
|
const arcos = [
|
||||||
|
{ r: 1.30, giro: 1.0, largo: 1.5, alfa: 0.55 },
|
||||||
|
{ r: 1.52, giro: -0.6, largo: 1.0, alfa: 0.38 },
|
||||||
|
{ r: 1.72, giro: 0.35, largo: 2.2, alfa: 0.22 },
|
||||||
|
];
|
||||||
|
for (const a of arcos) {
|
||||||
|
const inicio = fase * a.giro;
|
||||||
|
ctx.strokeStyle = hexA(color.vivo, a.alfa);
|
||||||
|
ctx.beginPath();
|
||||||
|
ctx.arc(cx, cy, radioBase * a.r, inicio, inicio + a.largo);
|
||||||
|
ctx.stroke();
|
||||||
|
}
|
||||||
|
|
||||||
|
// triangulo del icono
|
||||||
|
const rt = radioBase * 0.66;
|
||||||
|
ctx.strokeStyle = hexA(color.nucleo, 0.75);
|
||||||
|
ctx.lineWidth = Math.max(1.5, lado * 0.004);
|
||||||
|
ctx.beginPath();
|
||||||
|
for (let i = 0; i < 3; i++) {
|
||||||
|
const ang = (i / 3) * Math.PI * 2 - Math.PI / 2;
|
||||||
|
const x = cx + Math.cos(ang) * rt;
|
||||||
|
const y = cy + Math.sin(ang) * rt;
|
||||||
|
i === 0 ? ctx.moveTo(x, y) : ctx.lineTo(x, y);
|
||||||
|
}
|
||||||
|
ctx.closePath();
|
||||||
|
ctx.stroke();
|
||||||
|
|
||||||
|
// nucleo latiendo
|
||||||
|
const rn = radioBase * (0.26 + media * 0.14);
|
||||||
|
const gn = ctx.createRadialGradient(cx, cy, 0, cx, cy, rn * 2.4);
|
||||||
|
gn.addColorStop(0, hexA(color.nucleo, 1));
|
||||||
|
gn.addColorStop(0.4, hexA(color.vivo, 0.65));
|
||||||
|
gn.addColorStop(1, hexA(color.vivo, 0));
|
||||||
|
ctx.fillStyle = gn;
|
||||||
|
ctx.beginPath();
|
||||||
|
ctx.arc(cx, cy, rn * 2.4, 0, Math.PI * 2);
|
||||||
|
ctx.fill();
|
||||||
|
|
||||||
|
fase += estado === "hablando" ? 0.020 : 0.007;
|
||||||
|
requestAnimationFrame(dibujar);
|
||||||
|
}
|
||||||
|
|
||||||
|
function hexA(hex, alfa) {
|
||||||
|
const n = parseInt(hex.slice(1), 16);
|
||||||
|
return `rgba(${(n >> 16) & 255}, ${(n >> 8) & 255}, ${n & 255}, ${alfa})`;
|
||||||
|
}
|
||||||
|
|
||||||
|
/* ------------------------------------------------------------ eventos */
|
||||||
|
|
||||||
|
function ponEstado(nuevo) {
|
||||||
|
if (nuevo === estado) return;
|
||||||
|
estado = nuevo;
|
||||||
|
elEstado.textContent = ETIQUETAS[nuevo] || nuevo;
|
||||||
|
elEstado.className = "estado " + nuevo;
|
||||||
|
}
|
||||||
|
|
||||||
|
function ponMedidor(clave, porcentaje, texto) {
|
||||||
|
const fila = document.querySelector(`.medidor[data-clave="${clave}"]`);
|
||||||
|
if (!fila) return;
|
||||||
|
fila.querySelector("i").style.width = Math.min(100, porcentaje) + "%";
|
||||||
|
fila.querySelector(".cifra").textContent = texto;
|
||||||
|
}
|
||||||
|
|
||||||
|
// El rotulo dice lo que PASA, no lo que hace el boton: leer "escuchando" y
|
||||||
|
// ver el punto encendido no deja lugar a dudas; "silenciar" obligaria a
|
||||||
|
// deducir si es lo que hace o lo que esta puesto.
|
||||||
|
const ROTULOS = {
|
||||||
|
parar: { on: "parar", off: "reanudar" },
|
||||||
|
// El rotulo dice como ESTA: "escuchando" es que atiende todo lo que oiga,
|
||||||
|
// "solo con nombre" es que hay que llamarle antes de cada orden.
|
||||||
|
sueno: { on: "escuchando", off: "solo con nombre" },
|
||||||
|
};
|
||||||
|
|
||||||
|
function ponRotulo(boton) {
|
||||||
|
const textos = ROTULOS[boton.dataset.accion];
|
||||||
|
if (!textos) return;
|
||||||
|
boton.querySelector(".rotulo").textContent = textos[boton.dataset.estado] || "";
|
||||||
|
}
|
||||||
|
|
||||||
|
function ponControles(datos) {
|
||||||
|
for (const [accion, encendido] of Object.entries(datos)) {
|
||||||
|
const boton = document.querySelector(`.controles button[data-accion="${accion}"]`);
|
||||||
|
if (!boton) continue;
|
||||||
|
boton.dataset.estado = encendido ? "on" : "off";
|
||||||
|
ponRotulo(boton);
|
||||||
|
}
|
||||||
|
// Parado no es el estado de un boton, es el estado del asistente: se marca
|
||||||
|
// en el documento entero. Un HUD encendido con un boton pequeño en rojo se
|
||||||
|
// lee como "funcionando"; apagado no se puede confundir.
|
||||||
|
if (datos.parar !== undefined) {
|
||||||
|
document.body.classList.toggle("parado", !datos.parar);
|
||||||
|
if (!datos.parar) ponEstado("parado");
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
// Formatos: cada constante se lee de un vistazo o no sirve de nada, asi que
|
||||||
|
// las unidades se eligen segun la magnitud en vez de soltar el numero crudo.
|
||||||
|
const CONSTANTES = {
|
||||||
|
temperatura: (v) => `${v.toFixed(0)} °C`,
|
||||||
|
carga: (v) => v.map((x) => x.toFixed(2)).join(" "),
|
||||||
|
uptime: (v) => (v < 3600 ? `${(v / 60).toFixed(0)} min`
|
||||||
|
: v < 86400 ? `${(v / 3600).toFixed(1)} h`
|
||||||
|
: `${(v / 86400).toFixed(1)} dias`),
|
||||||
|
bateria: (v) => `${v.toFixed(0)} %`,
|
||||||
|
red: (v) => `${fmtKB(v.baja)} ↓ ${fmtKB(v.sube)} ↑`,
|
||||||
|
};
|
||||||
|
|
||||||
|
function fmtKB(kb) {
|
||||||
|
return kb >= 1024 ? `${(kb / 1024).toFixed(1)}M` : `${kb.toFixed(0)}K`;
|
||||||
|
}
|
||||||
|
|
||||||
|
function ponConstantes(datos) {
|
||||||
|
for (const [clave, formato] of Object.entries(CONSTANTES)) {
|
||||||
|
if (datos[clave] === undefined) continue;
|
||||||
|
const fila = document.querySelector(`.constantes li[data-clave="${clave}"]`);
|
||||||
|
if (!fila) continue;
|
||||||
|
fila.querySelector("b").textContent = formato(datos[clave]);
|
||||||
|
// 80 grados es donde empieza a preocupar en un portatil
|
||||||
|
if (clave === "temperatura") fila.classList.toggle("alerta", datos[clave] >= 80);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
// Las medidas de JARVIS: latencia, a donde va cada orden, y el RAG. Salen del
|
||||||
|
// diario y las manda el panel cada 5 s por el canal "medidas".
|
||||||
|
const MEDIDAS = {
|
||||||
|
lat_p50: (v) => `${v.toFixed(1)} s`,
|
||||||
|
lat_p95: (v) => `${v.toFixed(1)} s`,
|
||||||
|
pct_cerebro: (v) => `${v} %`,
|
||||||
|
pct_ruido: (v) => `${v} %`,
|
||||||
|
vol24: (v) => `${v}`,
|
||||||
|
rag: (v) => `${v.hit5} %`,
|
||||||
|
};
|
||||||
|
|
||||||
|
function ponMedidas(datos) {
|
||||||
|
if (!datos || !datos.n) return;
|
||||||
|
const caja = document.getElementById("rendimiento");
|
||||||
|
if (!caja) return;
|
||||||
|
for (const [clave, formato] of Object.entries(MEDIDAS)) {
|
||||||
|
if (datos[clave] === undefined) continue;
|
||||||
|
const fila = caja.querySelector(`li[data-clave="${clave}"]`);
|
||||||
|
if (!fila) continue;
|
||||||
|
fila.querySelector("b").textContent = formato(datos[clave]);
|
||||||
|
}
|
||||||
|
// latencia p95: por encima de 5 s la mediana ya se nota al hablar
|
||||||
|
const p95 = caja.querySelector('li[data-clave="lat_p95"]');
|
||||||
|
if (p95) p95.classList.toggle("alerta", datos.lat_p95 >= 8);
|
||||||
|
// ruido alto = Whisper oyendose a si mismo, envenena el diario
|
||||||
|
const rr = caja.querySelector('li[data-clave="pct_ruido"]');
|
||||||
|
if (rr) rr.classList.toggle("alerta", datos.pct_ruido >= 25);
|
||||||
|
|
||||||
|
// la barra de reparto: cerebro (lento) vs catalogo (instantaneo) vs ruido
|
||||||
|
const barra = document.getElementById("reparto");
|
||||||
|
if (barra) {
|
||||||
|
const set = (sel, f) => {
|
||||||
|
const t = barra.querySelector(sel);
|
||||||
|
if (t) t.style.setProperty("--f", Math.max(0, f));
|
||||||
|
};
|
||||||
|
set(".cerebro", datos.pct_cerebro);
|
||||||
|
set(".catalogo", datos.pct_catalogo);
|
||||||
|
set(".ruido", datos.pct_ruido);
|
||||||
|
barra.title = `al cerebro ${datos.pct_cerebro}% · catalogo ${datos.pct_catalogo}% · ruido ${datos.pct_ruido}% (ultimas ${datos.n})`;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
function ponNucleos(cargas) {
|
||||||
|
const caja = document.getElementById("nucleos");
|
||||||
|
while (caja.children.length < cargas.length) caja.appendChild(document.createElement("span"));
|
||||||
|
cargas.forEach((carga, i) => {
|
||||||
|
const celda = caja.children[i];
|
||||||
|
celda.style.setProperty("--carga", Math.min(100, carga) + "%");
|
||||||
|
celda.title = `nucleo ${i}: ${carga.toFixed(0)} %`;
|
||||||
|
});
|
||||||
|
}
|
||||||
|
|
||||||
|
function ponProcesos(lista) {
|
||||||
|
const caja = document.getElementById("procesos");
|
||||||
|
caja.textContent = "";
|
||||||
|
for (const p of lista) {
|
||||||
|
const li = document.createElement("li");
|
||||||
|
// el propio asistente se marca: es el que interesa vigilar
|
||||||
|
if (/newelle|ollama|llama|python/.test(p.nombre)) li.className = "propio";
|
||||||
|
const n = document.createElement("span");
|
||||||
|
n.className = "nombre";
|
||||||
|
n.textContent = p.nombre;
|
||||||
|
n.title = `pid ${p.pid}`;
|
||||||
|
const c = document.createElement("span");
|
||||||
|
c.className = "pcpu";
|
||||||
|
c.textContent = p.cpu.toFixed(0) + "%";
|
||||||
|
const m = document.createElement("span");
|
||||||
|
m.className = "pmem";
|
||||||
|
m.textContent = p.mem.toFixed(1) + "%";
|
||||||
|
li.append(n, c, m);
|
||||||
|
caja.appendChild(li);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/* ------------------------------------------------------- catalogo */
|
||||||
|
|
||||||
|
let CATALOGO = [];
|
||||||
|
|
||||||
|
function pintaCatalogo(filtro = "") {
|
||||||
|
const caja = document.getElementById("catalogo");
|
||||||
|
caja.textContent = "";
|
||||||
|
const f = filtro.trim().toLowerCase();
|
||||||
|
let total = 0;
|
||||||
|
|
||||||
|
for (const { grupo, acciones } of CATALOGO) {
|
||||||
|
const encajan = acciones.filter(
|
||||||
|
(a) => !f || a.frase.includes(f) || a.id.includes(f) || grupo.includes(f));
|
||||||
|
if (!encajan.length) continue;
|
||||||
|
|
||||||
|
const titulo = document.createElement("p");
|
||||||
|
titulo.className = "grupo";
|
||||||
|
titulo.textContent = `${grupo} · ${encajan.length}`;
|
||||||
|
caja.appendChild(titulo);
|
||||||
|
|
||||||
|
for (const a of encajan) {
|
||||||
|
total++;
|
||||||
|
const fila = document.createElement("div");
|
||||||
|
fila.className = "catalogo-item";
|
||||||
|
fila.title = "Pulsa para que te la explique en voz alta";
|
||||||
|
fila.tabIndex = 0;
|
||||||
|
fila.setAttribute("role", "button");
|
||||||
|
|
||||||
|
// Pulsar una accion la EXPLICA, no la ejecuta. Es la diferencia entre
|
||||||
|
// una lista de referencia y un campo de minas: uno mira "sabe hacer"
|
||||||
|
// justo cuando no sabe que hace cada cosa, y ahi el clic no puede
|
||||||
|
// disparar un comando en la maquina.
|
||||||
|
const explica = () => {
|
||||||
|
try {
|
||||||
|
window.webkit.messageHandlers.accion.postMessage("explica:" + a.id);
|
||||||
|
} catch (e) { /* suelto en el navegador: no hay a quien preguntar */ }
|
||||||
|
};
|
||||||
|
fila.addEventListener("click", explica);
|
||||||
|
fila.addEventListener("keydown", (ev) => {
|
||||||
|
if (ev.key === "Enter" || ev.key === " ") { ev.preventDefault(); explica(); }
|
||||||
|
});
|
||||||
|
|
||||||
|
const texto = document.createElement("span");
|
||||||
|
texto.textContent = a.frase;
|
||||||
|
fila.appendChild(texto);
|
||||||
|
|
||||||
|
// las que esperan algo detras se marcan: si no, uno dice la frase a
|
||||||
|
// secas, no pasa nada y parece que la accion esta rota
|
||||||
|
if (a.captura) {
|
||||||
|
const hueco = document.createElement("span");
|
||||||
|
hueco.className = "hueco";
|
||||||
|
hueco.textContent = "+ que";
|
||||||
|
fila.appendChild(hueco);
|
||||||
|
}
|
||||||
|
if (a.confirmar) {
|
||||||
|
const aviso = document.createElement("span");
|
||||||
|
aviso.className = "aviso";
|
||||||
|
aviso.textContent = "⚠";
|
||||||
|
aviso.title = "pide confirmacion antes de hacerlo";
|
||||||
|
fila.appendChild(aviso);
|
||||||
|
}
|
||||||
|
caja.appendChild(fila);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
if (!total) {
|
||||||
|
const vacio = document.createElement("p");
|
||||||
|
vacio.className = "vacio";
|
||||||
|
vacio.textContent = "nada encaja con ese filtro";
|
||||||
|
caja.appendChild(vacio);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
// Lista numerada de resultados de una busqueda: se puede leer y luego decir
|
||||||
|
// "abre el tercero". Va en la vista de acciones hechas, encabezada por el
|
||||||
|
// titulo de la busqueda.
|
||||||
|
function muestraCandado(datos) {
|
||||||
|
const c = document.getElementById("candado");
|
||||||
|
const msg = document.getElementById("candado-msg");
|
||||||
|
msg.textContent = datos.mensaje || "Introduzca la contraseña";
|
||||||
|
msg.classList.toggle("error", !!datos.error);
|
||||||
|
c.classList.remove("oculto");
|
||||||
|
const clave = document.getElementById("candado-clave");
|
||||||
|
clave.value = "";
|
||||||
|
clave.focus();
|
||||||
|
}
|
||||||
|
|
||||||
|
function enviaClave() {
|
||||||
|
const clave = document.getElementById("candado-clave");
|
||||||
|
if (!clave.value) return;
|
||||||
|
try {
|
||||||
|
window.webkit.messageHandlers.accion.postMessage("desbloquear:" + clave.value);
|
||||||
|
} catch (e) { /* suelto en el navegador: no hay a quien mandarla */ }
|
||||||
|
clave.value = "";
|
||||||
|
document.getElementById("candado-msg").textContent = "Comprobando...";
|
||||||
|
}
|
||||||
|
|
||||||
|
function muestraResultados(datos) {
|
||||||
|
const li = document.createElement("li");
|
||||||
|
li.className = "resultados";
|
||||||
|
const h = document.createElement("span");
|
||||||
|
h.className = "herramienta";
|
||||||
|
h.textContent = datos.titulo || "resultados";
|
||||||
|
li.appendChild(h);
|
||||||
|
const ol = document.createElement("ol");
|
||||||
|
for (const item of (datos.items || [])) {
|
||||||
|
const el = document.createElement("li");
|
||||||
|
el.value = item.n;
|
||||||
|
el.textContent = item.texto;
|
||||||
|
ol.appendChild(el);
|
||||||
|
}
|
||||||
|
li.appendChild(ol);
|
||||||
|
elRegistro.prepend(li);
|
||||||
|
while (elRegistro.children.length > MAX_ACCIONES) {
|
||||||
|
elRegistro.lastElementChild.remove();
|
||||||
|
}
|
||||||
|
cambiaVista("registro");
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
/* ------------------------------------------------------- la consola ---
|
||||||
|
|
||||||
|
Lo que echa de menos cualquiera que venga de una terminal: ver que esta
|
||||||
|
pasando MIENTRAS pasa, y poder cortarlo. Las tarjetas dicen el estado;
|
||||||
|
esto dice el detalle, linea a linea y en orden. */
|
||||||
|
|
||||||
|
const elConsola = document.getElementById("consola");
|
||||||
|
const elConsolaEstado = document.getElementById("consola-estado");
|
||||||
|
const MAX_LINEAS_CONSOLA = 400; // mas que esto no se lee y pesa
|
||||||
|
|
||||||
|
function aConsola(texto, clase) {
|
||||||
|
if (!elConsola || !texto) return;
|
||||||
|
const linea = document.createElement("span");
|
||||||
|
linea.className = "linea " + (clase || "");
|
||||||
|
const hora = new Date().toTimeString().slice(0, 8);
|
||||||
|
linea.textContent = hora + " " + texto;
|
||||||
|
elConsola.appendChild(linea);
|
||||||
|
while (elConsola.childElementCount > MAX_LINEAS_CONSOLA) {
|
||||||
|
elConsola.firstElementChild.remove();
|
||||||
|
}
|
||||||
|
// pegada abajo, como una terminal: si el usuario ha subido a leer, se
|
||||||
|
// respeta y no se le arrastra el scroll
|
||||||
|
const pegada = elConsola.scrollHeight - elConsola.scrollTop
|
||||||
|
- elConsola.clientHeight < 60;
|
||||||
|
if (pegada) elConsola.scrollTop = elConsola.scrollHeight;
|
||||||
|
}
|
||||||
|
|
||||||
|
function consolaEstado(texto, ocupado) {
|
||||||
|
if (!elConsolaEstado) return;
|
||||||
|
elConsolaEstado.textContent = texto;
|
||||||
|
elConsolaEstado.classList.toggle("ocupado", Boolean(ocupado));
|
||||||
|
const b = document.getElementById("consola-parar");
|
||||||
|
if (b) b.disabled = !ocupado;
|
||||||
|
}
|
||||||
|
|
||||||
|
/* --------------------------------------------------- tareas en marcha */
|
||||||
|
|
||||||
|
// Cuanto se queda en pantalla una tarea que termino bien y fue rapida.
|
||||||
|
// Las lentas y las que fallan NO se van solas: si algo tardo doce segundos
|
||||||
|
// uno quiere leer que salio, y si fallo, mas todavia.
|
||||||
|
const RAPIDA_S = 2.0;
|
||||||
|
const DESVANECE_MS = 3000;
|
||||||
|
|
||||||
|
const elTareas = document.getElementById("tareas");
|
||||||
|
const tarjetas = new Map(); // id -> {nodo, reloj, fin}
|
||||||
|
|
||||||
|
function mandaTarea(orden, id) {
|
||||||
|
try {
|
||||||
|
window.webkit.messageHandlers.accion.postMessage(`${orden}:${id}`);
|
||||||
|
} catch (e) {
|
||||||
|
// suelto en el navegador, sin Python detras: se simula para poder ver
|
||||||
|
// el diseño sin levantar la aplicacion entera
|
||||||
|
if (orden === "cerrar_tarea") quitaTarjeta(id);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
function creaTarjeta(t) {
|
||||||
|
const nodo = document.createElement("div");
|
||||||
|
nodo.className = "tarea";
|
||||||
|
nodo.dataset.id = t.id;
|
||||||
|
|
||||||
|
const titulo = document.createElement("div");
|
||||||
|
titulo.className = "titulo";
|
||||||
|
titulo.textContent = t.titulo;
|
||||||
|
titulo.title = t.titulo;
|
||||||
|
|
||||||
|
const fila = document.createElement("div");
|
||||||
|
fila.className = "fila";
|
||||||
|
|
||||||
|
const reloj = document.createElement("span");
|
||||||
|
reloj.className = "reloj";
|
||||||
|
const giro = document.createElement("i");
|
||||||
|
giro.className = "giro";
|
||||||
|
reloj.append(giro, document.createTextNode("0.0s"));
|
||||||
|
|
||||||
|
const parar = document.createElement("button");
|
||||||
|
parar.textContent = "■";
|
||||||
|
parar.title = "Parar esta tarea";
|
||||||
|
parar.addEventListener("click", () => mandaTarea("parar_tarea", t.id));
|
||||||
|
|
||||||
|
const cerrar = document.createElement("button");
|
||||||
|
cerrar.textContent = "×";
|
||||||
|
cerrar.title = "Cerrar la tarjeta (si sigue viva, la para)";
|
||||||
|
cerrar.addEventListener("click", () => mandaTarea("cerrar_tarea", t.id));
|
||||||
|
|
||||||
|
const botones = document.createElement("span");
|
||||||
|
botones.append(parar, cerrar);
|
||||||
|
fila.append(reloj, botones);
|
||||||
|
|
||||||
|
const eco = document.createElement("div");
|
||||||
|
eco.className = "eco";
|
||||||
|
|
||||||
|
nodo.append(titulo, fila, eco);
|
||||||
|
elTareas.append(nodo);
|
||||||
|
|
||||||
|
const ficha = { nodo, reloj, parar, eco, fin: null };
|
||||||
|
tarjetas.set(t.id, ficha);
|
||||||
|
return ficha;
|
||||||
|
}
|
||||||
|
|
||||||
|
function ponTarea(t) {
|
||||||
|
const nueva = !tarjetas.has(t.id);
|
||||||
|
const ficha = tarjetas.get(t.id) || creaTarjeta(t);
|
||||||
|
// la consola cuenta el detalle que no cabe en la tarjeta
|
||||||
|
if (nueva) aConsola("$ " + t.titulo, "orden");
|
||||||
|
const ultima = (t.lineas && t.lineas.length) ? t.lineas[t.lineas.length - 1] : "";
|
||||||
|
if (ultima && ficha.ultimoEco !== ultima) { ficha.ultimoEco = ultima; aConsola(" " + ultima); }
|
||||||
|
if (t.estado !== "corriendo" && ficha.estadoPrevio !== t.estado) {
|
||||||
|
ficha.estadoPrevio = t.estado;
|
||||||
|
aConsola(" → " + t.estado + " (" + t.segundos.toFixed(1) + "s)",
|
||||||
|
t.estado === "fallo" ? "malo" : "bueno");
|
||||||
|
}
|
||||||
|
const vivas = [...tarjetas.values()].filter((f) => f.fin === null).length;
|
||||||
|
consolaEstado(vivas ? vivas + " en marcha" : "en reposo", vivas > 0);
|
||||||
|
const { nodo, eco, parar } = ficha;
|
||||||
|
|
||||||
|
nodo.dataset.estado = t.estado;
|
||||||
|
eco.textContent = (t.lineas && t.lineas.length)
|
||||||
|
? t.lineas[t.lineas.length - 1] : "";
|
||||||
|
|
||||||
|
if (t.estado === "corriendo") {
|
||||||
|
ficha.fin = null;
|
||||||
|
parar.disabled = false;
|
||||||
|
ponReloj(ficha, t.segundos);
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
|
||||||
|
// Terminada: el reloj se congela en lo que tardo y el boton de parar ya
|
||||||
|
// no tiene nada que parar.
|
||||||
|
ficha.fin = t.segundos;
|
||||||
|
parar.disabled = true;
|
||||||
|
ponReloj(ficha, t.segundos);
|
||||||
|
|
||||||
|
if (t.estado === "hecha" && t.segundos <= RAPIDA_S) {
|
||||||
|
// Lo instantaneo no merece una tarjeta permanente: aparece, confirma
|
||||||
|
// que se hizo, y se va sola.
|
||||||
|
setTimeout(() => {
|
||||||
|
nodo.classList.add("desvanece");
|
||||||
|
setTimeout(() => quitaTarjeta(t.id), 520);
|
||||||
|
}, DESVANECE_MS);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
function ponReloj(ficha, segundos) {
|
||||||
|
// El nodo de texto es el segundo hijo: el primero es el punto que late
|
||||||
|
ficha.reloj.lastChild.textContent = segundos.toFixed(1) + "s";
|
||||||
|
}
|
||||||
|
|
||||||
|
function quitaTarjeta(id) {
|
||||||
|
const ficha = tarjetas.get(id);
|
||||||
|
if (!ficha) return;
|
||||||
|
ficha.nodo.remove();
|
||||||
|
tarjetas.delete(id);
|
||||||
|
}
|
||||||
|
|
||||||
|
// El reloj de las vivas lo lleva el HUD, no Python: si el tiempo solo
|
||||||
|
// avanzase con los avisos del puente, una tarea callada —un `find` largo que
|
||||||
|
// no escribe nada— tendria el contador congelado y pareceria colgada.
|
||||||
|
setInterval(() => {
|
||||||
|
for (const [id, ficha] of tarjetas) {
|
||||||
|
if (ficha.fin !== null) continue;
|
||||||
|
const t = parseFloat(ficha.reloj.lastChild.textContent) || 0;
|
||||||
|
ponReloj(ficha, t + 0.1);
|
||||||
|
}
|
||||||
|
}, 100);
|
||||||
|
|
||||||
|
function anotaAccion(datos) {
|
||||||
|
const li = document.createElement("li");
|
||||||
|
if (datos.error) li.className = "error";
|
||||||
|
const h = document.createElement("span");
|
||||||
|
h.className = "herramienta";
|
||||||
|
h.textContent = datos.herramienta || "accion";
|
||||||
|
const s = document.createElement("span");
|
||||||
|
s.className = "salida";
|
||||||
|
s.textContent = datos.salida || "";
|
||||||
|
li.append(h, s);
|
||||||
|
elRegistro.prepend(li);
|
||||||
|
// al ejecutar algo se salta sola a la vista de lo hecho: es lo que uno
|
||||||
|
// quiere ver en ese momento
|
||||||
|
cambiaVista("registro");
|
||||||
|
while (elRegistro.children.length > MAX_ACCIONES) {
|
||||||
|
elRegistro.lastElementChild.remove();
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
window.jarvis = {
|
||||||
|
recibe(mensaje) {
|
||||||
|
const { tipo, datos } = mensaje;
|
||||||
|
|
||||||
|
if (tipo === "pulso") {
|
||||||
|
for (let i = 0; i < BANDAS && i < datos.niveles.length; i++) {
|
||||||
|
nivelesObjetivo[i] = datos.niveles[i];
|
||||||
|
}
|
||||||
|
ponEstado(datos.estado);
|
||||||
|
|
||||||
|
} else if (tipo === "estado") {
|
||||||
|
ponEstado(datos);
|
||||||
|
|
||||||
|
} else if (tipo === "dicho") {
|
||||||
|
// Lo que ha oido, tanto si le hace caso como si no. Lo segundo importa
|
||||||
|
// igual o mas: sin verlo, un JARVIS que te oye pero te ignora —porque
|
||||||
|
// no le has llamado o porque esta bloqueado— es indistinguible de un
|
||||||
|
// microfono roto.
|
||||||
|
ponDicho(datos.texto, datos.atendido !== false, datos.motivo);
|
||||||
|
aConsolaDicho(datos.texto, datos.atendido !== false, datos.motivo);
|
||||||
|
|
||||||
|
} else if (tipo === "preguntando") {
|
||||||
|
// Una pregunta en el aire cambia lo que significa hablar: lo siguiente
|
||||||
|
// que digas es la RESPUESTA, no una orden. Si no se ve, uno contesta
|
||||||
|
// "informes" y no entiende por que no ha buscado nada.
|
||||||
|
document.documentElement.classList.toggle("preguntando",
|
||||||
|
Boolean(datos.texto));
|
||||||
|
if (datos.texto) {
|
||||||
|
ponEstado("preguntando");
|
||||||
|
aConsola("? " + datos.texto, "orden");
|
||||||
|
}
|
||||||
|
|
||||||
|
} else if (tipo === "respuesta") {
|
||||||
|
ponDicho(datos.texto, true, "");
|
||||||
|
aConsola(" " + datos.texto, "bueno");
|
||||||
|
|
||||||
|
} else if (tipo === "accion") {
|
||||||
|
anotaAccion(datos);
|
||||||
|
|
||||||
|
} else if (tipo === "tarea") {
|
||||||
|
ponTarea(datos);
|
||||||
|
|
||||||
|
} else if (tipo === "tarea_fuera") {
|
||||||
|
quitaTarjeta(datos.id);
|
||||||
|
|
||||||
|
} else if (tipo === "bloqueo") {
|
||||||
|
muestraCandado(datos);
|
||||||
|
|
||||||
|
} else if (tipo === "desbloqueado") {
|
||||||
|
document.getElementById("candado").classList.add("oculto");
|
||||||
|
|
||||||
|
} else if (tipo === "resultados") {
|
||||||
|
muestraResultados(datos);
|
||||||
|
|
||||||
|
} else if (tipo === "voz") {
|
||||||
|
ponVoz(datos);
|
||||||
|
|
||||||
|
} else if (tipo === "cerebro") {
|
||||||
|
ponCerebro(datos);
|
||||||
|
|
||||||
|
} else if (tipo === "catalogo") {
|
||||||
|
CATALOGO = datos;
|
||||||
|
pintaCatalogo(document.getElementById("filtro").value);
|
||||||
|
|
||||||
|
} else if (tipo === "controles") {
|
||||||
|
ponControles(datos);
|
||||||
|
|
||||||
|
} else if (tipo === "medidas") {
|
||||||
|
ponMedidas(datos);
|
||||||
|
|
||||||
|
} else if (tipo === "telemetria") {
|
||||||
|
if (datos.nucleos) ponNucleos(datos.nucleos);
|
||||||
|
ponConstantes(datos);
|
||||||
|
if (datos.swap) {
|
||||||
|
ponMedidor("swap", 100 * datos.swap.usada / datos.swap.total,
|
||||||
|
`${datos.swap.usada.toFixed(1)}/${datos.swap.total.toFixed(0)} GB`);
|
||||||
|
}
|
||||||
|
if (datos.disco) {
|
||||||
|
ponMedidor("disco", 100 * datos.disco.usado / datos.disco.total,
|
||||||
|
`${datos.disco.usado.toFixed(2)}/${datos.disco.total.toFixed(1)} TB`);
|
||||||
|
}
|
||||||
|
if (datos.procesos) ponProcesos(datos.procesos);
|
||||||
|
if (datos.cpu !== undefined) {
|
||||||
|
ponMedidor("cpu", datos.cpu, datos.cpu.toFixed(0) + " %");
|
||||||
|
}
|
||||||
|
if (datos.ram) {
|
||||||
|
ponMedidor("ram", 100 * datos.ram.usada / datos.ram.total,
|
||||||
|
`${datos.ram.usada.toFixed(0)}/${datos.ram.total.toFixed(0)} GB`);
|
||||||
|
}
|
||||||
|
if (datos.gpu) {
|
||||||
|
ponMedidor("gpu", datos.gpu.uso, datos.gpu.uso.toFixed(0) + " %");
|
||||||
|
ponMedidor("vram",
|
||||||
|
100 * datos.gpu.vram_usada / datos.gpu.vram_total,
|
||||||
|
`${datos.gpu.vram_usada.toFixed(1)}/${datos.gpu.vram_total.toFixed(1)} GB`);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
},
|
||||||
|
};
|
||||||
|
|
||||||
|
/* ------------------------------------------------------------ arranque */
|
||||||
|
|
||||||
|
// Los interruptores NO se pintan al pulsarlos: se manda la orden y se espera
|
||||||
|
// a que Python conteste con el estado real (evento "controles"). Asi el
|
||||||
|
// boton nunca dice "silenciado" con el microfono abierto.
|
||||||
|
document.querySelectorAll(".controles button[data-accion]").forEach((boton) => {
|
||||||
|
boton.addEventListener("click", () => {
|
||||||
|
try {
|
||||||
|
window.webkit.messageHandlers.accion.postMessage(boton.dataset.accion);
|
||||||
|
} catch (e) {
|
||||||
|
// suelto en el navegador: no hay Python, se conmuta a mano para poder
|
||||||
|
// ver como queda el diseño
|
||||||
|
if (boton.dataset.estado) {
|
||||||
|
boton.dataset.estado = boton.dataset.estado === "on" ? "off" : "on";
|
||||||
|
ponRotulo(boton);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
});
|
||||||
|
});
|
||||||
|
|
||||||
|
function cambiaVista(cual) {
|
||||||
|
for (const b of document.querySelectorAll(".pestanas button")) {
|
||||||
|
b.classList.toggle("activa", b.dataset.vista === cual);
|
||||||
|
}
|
||||||
|
for (const v of document.querySelectorAll(".vista")) {
|
||||||
|
v.classList.toggle("oculta", v.id !== "vista-" + cual);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
document.querySelectorAll(".pestanas button").forEach((b) => {
|
||||||
|
b.addEventListener("click", () => cambiaVista(b.dataset.vista));
|
||||||
|
});
|
||||||
|
|
||||||
|
document.getElementById("filtro").addEventListener("input", (e) => {
|
||||||
|
pintaCatalogo(e.target.value);
|
||||||
|
});
|
||||||
|
|
||||||
|
document.getElementById("candado-ok").addEventListener("click", enviaClave);
|
||||||
|
document.getElementById("candado-clave").addEventListener("keydown", (e) => {
|
||||||
|
if (e.key === "Enter") enviaClave();
|
||||||
|
});
|
||||||
|
|
||||||
|
// Cortar lo que este corriendo: el boton y Ctrl+C, que es lo que los dedos
|
||||||
|
// hacen solos cuando algo se atasca.
|
||||||
|
function cortarTodo() {
|
||||||
|
let n = 0;
|
||||||
|
for (const [id, ficha] of tarjetas) {
|
||||||
|
if (ficha.fin === null) { mandaTarea("parar_tarea", id); n++; }
|
||||||
|
}
|
||||||
|
aConsola(n ? "^C cortando " + n + " tarea(s)" : "^C no hay nada corriendo", "malo");
|
||||||
|
}
|
||||||
|
|
||||||
|
const botonCortar = document.getElementById("consola-parar");
|
||||||
|
if (botonCortar) botonCortar.addEventListener("click", cortarTodo);
|
||||||
|
|
||||||
|
document.addEventListener("keydown", (ev) => {
|
||||||
|
if (ev.ctrlKey && (ev.key === "c" || ev.key === "C")) {
|
||||||
|
// si hay texto seleccionado es que quieren copiar, no cortar
|
||||||
|
if (String(window.getSelection() || "").length) return;
|
||||||
|
ev.preventDefault();
|
||||||
|
cortarTodo();
|
||||||
|
}
|
||||||
|
});
|
||||||
|
|
||||||
|
// Lanza la tanda de prueba. No cambia nada en el boton: lo que hay que mirar
|
||||||
|
// son las tarjetas, que es justo lo que se quiere comprobar.
|
||||||
|
document.getElementById("prueba").addEventListener("click", (ev) => {
|
||||||
|
const b = ev.currentTarget;
|
||||||
|
b.disabled = true;
|
||||||
|
b.querySelector(".rotulo").textContent = "probando";
|
||||||
|
setTimeout(() => {
|
||||||
|
b.disabled = false;
|
||||||
|
b.querySelector(".rotulo").textContent = "prueba";
|
||||||
|
}, 4000);
|
||||||
|
try {
|
||||||
|
window.webkit.messageHandlers.accion.postMessage("prueba");
|
||||||
|
} catch (e) { /* suelto en el navegador: no hay Python que lance nada */ }
|
||||||
|
});
|
||||||
|
|
||||||
|
// No se pinta al pulsar: rota Python y contesta con la voz que quedo. Mientras
|
||||||
|
// llega, se avisa de que esta en ello, que cambiar de motor tarda un momento.
|
||||||
|
document.getElementById("voz").addEventListener("click", (ev) => {
|
||||||
|
ev.currentTarget.querySelector(".rotulo").textContent = "voz: ...";
|
||||||
|
try {
|
||||||
|
window.webkit.messageHandlers.accion.postMessage("voz:siguiente");
|
||||||
|
} catch (e) { /* suelto en el navegador: no hay Python que rote nada */ }
|
||||||
|
});
|
||||||
|
|
||||||
|
const botonCerebro = document.getElementById("cerebro");
|
||||||
|
if (botonCerebro) botonCerebro.addEventListener("click", (ev) => {
|
||||||
|
ev.currentTarget.querySelector(".rotulo").textContent = "cerebro: ...";
|
||||||
|
try {
|
||||||
|
window.webkit.messageHandlers.accion.postMessage("cerebro:siguiente");
|
||||||
|
} catch (e) { /* suelto en el navegador: no hay Python que rote nada */ }
|
||||||
|
});
|
||||||
|
|
||||||
|
window.addEventListener("resize", ajustarLienzo);
|
||||||
|
ajustarLienzo();
|
||||||
|
leeColores();
|
||||||
|
requestAnimationFrame(dibujar);
|
||||||
|
|
||||||
|
try {
|
||||||
|
window.webkit.messageHandlers.listo.postMessage("listo");
|
||||||
|
} catch (e) {
|
||||||
|
// Abierto en un navegador normal: se llena solo con datos falsos, para
|
||||||
|
// poder iterar el diseño sin arrancar Newelle.
|
||||||
|
ponEstado("escuchando");
|
||||||
|
setInterval(() => {
|
||||||
|
for (let i = 0; i < BANDAS; i++) nivelesObjetivo[i] = Math.random() * 0.9;
|
||||||
|
}, 120);
|
||||||
|
|
||||||
|
elDicho.textContent = "how much disk space is left?";
|
||||||
|
elDicho.classList.add("visible");
|
||||||
|
|
||||||
|
[
|
||||||
|
{ herramienta: "run_command", salida: "df -h /\n/dev/nvme0n1p2 916G 70G 846G 8% /" },
|
||||||
|
{ herramienta: "system_info", salida: "62 GB RAM · 16 nucleos · NVIDIA T1200 4 GB" },
|
||||||
|
{ herramienta: "websearch", salida: "3 resultados descartados por poco fiables" },
|
||||||
|
].forEach(anotaAccion);
|
||||||
|
cambiaVista("catalogo");
|
||||||
|
|
||||||
|
window.jarvis.recibe({ tipo: "catalogo", datos: [
|
||||||
|
{ grupo: "sistema", acciones: [
|
||||||
|
{ id: "disco_libre", frase: "cuanto espacio queda", captura: false, confirmar: false },
|
||||||
|
{ id: "memoria", frase: "cuanta memoria", captura: false, confirmar: false },
|
||||||
|
{ id: "temperatura", frase: "que temperatura hay", captura: false, confirmar: false },
|
||||||
|
]},
|
||||||
|
{ grupo: "ficheros", acciones: [
|
||||||
|
{ id: "buscar_fichero", frase: "busca el fichero", captura: true, confirmar: false },
|
||||||
|
{ id: "proceso_matar", frase: "mata el proceso", captura: true, confirmar: true },
|
||||||
|
]},
|
||||||
|
{ grupo: "firefox", acciones: [
|
||||||
|
{ id: "ff_buscar_youtube", frase: "busca en youtube", captura: true, confirmar: false },
|
||||||
|
{ id: "ff_gmail", frase: "abre el correo", captura: false, confirmar: false },
|
||||||
|
]},
|
||||||
|
]});
|
||||||
|
|
||||||
|
window.jarvis.recibe({ tipo: "telemetria", datos: {
|
||||||
|
cpu: 34,
|
||||||
|
ram: { usada: 18.4, total: 62.5 },
|
||||||
|
gpu: { uso: 71, vram_usada: 2.9, vram_total: 4.0 },
|
||||||
|
nucleos: Array.from({ length: 16 }, (_, i) => 20 + ((i * 37) % 70)),
|
||||||
|
swap: { usada: 0.4, total: 1.0 },
|
||||||
|
disco: { usado: 1.01, total: 1.9 },
|
||||||
|
temperatura: 59,
|
||||||
|
carga: [1.81, 2.96, 4.08],
|
||||||
|
uptime: 21600,
|
||||||
|
bateria: 100,
|
||||||
|
red: { baja: 1840.5, sube: 220.2 },
|
||||||
|
procesos: [
|
||||||
|
{ pid: 2693, nombre: "ollama", cpu: 182.4, mem: 5.8 },
|
||||||
|
{ pid: 1436, nombre: "newelle", cpu: 33.5, mem: 1.8 },
|
||||||
|
{ pid: 9422, nombre: "firefox-esr", cpu: 12.1, mem: 4.2 },
|
||||||
|
{ pid: 3829, nombre: "gnome-shell", cpu: 6.3, mem: 2.1 },
|
||||||
|
{ pid: 1201, nombre: "pipewire", cpu: 2.0, mem: 0.3 },
|
||||||
|
],
|
||||||
|
}});
|
||||||
|
}
|
||||||
|
})();
|
||||||
179
nucleo/cara/hud/index.html
Normal file
179
nucleo/cara/hud/index.html
Normal file
|
|
@ -0,0 +1,179 @@
|
||||||
|
<!DOCTYPE html>
|
||||||
|
<!-- HUD de JARVIS. Se carga desde config/jarvis-hud/, asi que este fichero
|
||||||
|
se puede editar y recargar la pestaña sin recompilar el flatpak. -->
|
||||||
|
<html lang="es">
|
||||||
|
<head>
|
||||||
|
<meta charset="utf-8">
|
||||||
|
<title>JARVIS</title>
|
||||||
|
<link rel="stylesheet" href="style.css">
|
||||||
|
</head>
|
||||||
|
<body>
|
||||||
|
<main class="hud">
|
||||||
|
|
||||||
|
<!-- columna izquierda: constantes de la maquina -->
|
||||||
|
<aside class="telemetria" id="telemetria">
|
||||||
|
<h2>sistema</h2>
|
||||||
|
<div class="medidor" data-clave="cpu">
|
||||||
|
<span class="etiqueta">cpu</span>
|
||||||
|
<div class="barra"><i></i></div>
|
||||||
|
<span class="cifra">--</span>
|
||||||
|
</div>
|
||||||
|
<div class="medidor" data-clave="ram">
|
||||||
|
<span class="etiqueta">ram</span>
|
||||||
|
<div class="barra"><i></i></div>
|
||||||
|
<span class="cifra">--</span>
|
||||||
|
</div>
|
||||||
|
<div class="medidor" data-clave="gpu">
|
||||||
|
<span class="etiqueta">gpu</span>
|
||||||
|
<div class="barra"><i></i></div>
|
||||||
|
<span class="cifra">--</span>
|
||||||
|
</div>
|
||||||
|
<div class="medidor" data-clave="vram">
|
||||||
|
<span class="etiqueta">vram</span>
|
||||||
|
<div class="barra"><i></i></div>
|
||||||
|
<span class="cifra">--</span>
|
||||||
|
</div>
|
||||||
|
|
||||||
|
<div class="medidor" data-clave="swap">
|
||||||
|
<span class="etiqueta">swap</span>
|
||||||
|
<div class="barra"><i></i></div>
|
||||||
|
<span class="cifra">--</span>
|
||||||
|
</div>
|
||||||
|
<div class="medidor" data-clave="disco">
|
||||||
|
<span class="etiqueta">disco</span>
|
||||||
|
<div class="barra"><i></i></div>
|
||||||
|
<span class="cifra">--</span>
|
||||||
|
</div>
|
||||||
|
|
||||||
|
<h2 class="separado">nucleos</h2>
|
||||||
|
<div class="nucleos" id="nucleos"></div>
|
||||||
|
|
||||||
|
<!-- constantes: no llevan barra porque no son porcentajes de nada -->
|
||||||
|
<ul class="constantes" id="constantes">
|
||||||
|
<li data-clave="temperatura"><span>temp</span><b>--</b></li>
|
||||||
|
<li data-clave="carga"><span>carga</span><b>--</b></li>
|
||||||
|
<li data-clave="red"><span>red</span><b>--</b></li>
|
||||||
|
<li data-clave="uptime"><span>encendido</span><b>--</b></li>
|
||||||
|
<li data-clave="bateria"><span>bateria</span><b>--</b></li>
|
||||||
|
</ul>
|
||||||
|
|
||||||
|
<h2 class="separado">procesos</h2>
|
||||||
|
<ul class="procesos" id="procesos"></ul>
|
||||||
|
|
||||||
|
<!-- rendimiento del propio JARVIS: sale del diario, no del sistema -->
|
||||||
|
<h2 class="separado">rendimiento</h2>
|
||||||
|
<div class="reparto" id="reparto" title="a donde va cada orden">
|
||||||
|
<span class="tramo cerebro" style="--f:0"></span>
|
||||||
|
<span class="tramo catalogo" style="--f:0"></span>
|
||||||
|
<span class="tramo ruido" style="--f:0"></span>
|
||||||
|
</div>
|
||||||
|
<ul class="constantes" id="rendimiento">
|
||||||
|
<li data-clave="lat_p50"><span>latencia med.</span><b>--</b></li>
|
||||||
|
<li data-clave="lat_p95"><span>latencia p95</span><b>--</b></li>
|
||||||
|
<li data-clave="pct_cerebro"><span>al cerebro</span><b>--</b></li>
|
||||||
|
<li data-clave="pct_ruido"><span>ruido</span><b>--</b></li>
|
||||||
|
<li data-clave="vol24"><span>frases 24h</span><b>--</b></li>
|
||||||
|
<li data-clave="rag"><span>RAG hit@5</span><b>--</b></li>
|
||||||
|
</ul>
|
||||||
|
</aside>
|
||||||
|
|
||||||
|
<!-- centro: el reactor, el estado y lo que hay en marcha -->
|
||||||
|
<section class="nucleo">
|
||||||
|
<canvas id="reactor" width="520" height="520"></canvas>
|
||||||
|
<p class="estado" id="estado">en reposo</p>
|
||||||
|
<p class="dicho" id="dicho"></p>
|
||||||
|
|
||||||
|
<!-- una tarjetita por orden en marcha. Van aqui debajo y no flotando
|
||||||
|
sobre el reactor para que quepan varias sin taparlo. -->
|
||||||
|
<div class="tareas" id="tareas"></div>
|
||||||
|
</section>
|
||||||
|
|
||||||
|
<!-- columna derecha: lo que va haciendo -->
|
||||||
|
<aside class="acciones">
|
||||||
|
<h2>
|
||||||
|
acciones
|
||||||
|
<span class="pestanas">
|
||||||
|
<button data-vista="catalogo" class="activa">sabe hacer</button>
|
||||||
|
<button data-vista="registro">hechas</button>
|
||||||
|
<button data-vista="consola">consola</button>
|
||||||
|
</span>
|
||||||
|
</h2>
|
||||||
|
|
||||||
|
<!-- lo que sabe hacer: sale de las acciones rapidas, no esta escrito aqui -->
|
||||||
|
<div class="vista" id="vista-catalogo">
|
||||||
|
<input id="filtro" type="search" placeholder="filtrar..." autocomplete="off">
|
||||||
|
<div id="catalogo"></div>
|
||||||
|
</div>
|
||||||
|
|
||||||
|
<!-- lo que va haciendo -->
|
||||||
|
<div class="vista oculta" id="vista-registro">
|
||||||
|
<ul id="registro"></ul>
|
||||||
|
</div>
|
||||||
|
|
||||||
|
<!-- La consola: lo que esta pasando AHORA, linea a linea, como en una
|
||||||
|
terminal. Con su boton de cortar, que es lo que se echa de menos
|
||||||
|
cuando algo se queda pensando y no sabes ni que esta haciendo. -->
|
||||||
|
<div class="vista oculta" id="vista-consola">
|
||||||
|
<div class="consola-barra">
|
||||||
|
<span id="consola-estado">en reposo</span>
|
||||||
|
<button id="consola-parar" title="Cortar lo que se este ejecutando (Ctrl+C)">■ cortar</button>
|
||||||
|
</div>
|
||||||
|
<pre id="consola"></pre>
|
||||||
|
</div>
|
||||||
|
</aside>
|
||||||
|
|
||||||
|
</main>
|
||||||
|
|
||||||
|
<nav class="controles">
|
||||||
|
<button data-accion="parar" data-estado="on" class="principal"
|
||||||
|
title="Cierra el microfono y corta la voz. Pulsa otra vez para reanudar">
|
||||||
|
<span class="punto"></span>
|
||||||
|
<span class="rotulo">parar</span>
|
||||||
|
</button>
|
||||||
|
|
||||||
|
<!-- Rota entre las voces disponibles y estrena la nueva diciendo una frase.
|
||||||
|
El rotulo lo pone Python al confirmar el cambio, no el clic. -->
|
||||||
|
<button id="voz" class="secundario" title="Cambiar la voz. La estrena diciendo una frase">
|
||||||
|
<span class="rotulo">voz</span>
|
||||||
|
</button>
|
||||||
|
|
||||||
|
<!-- Dormir / despertar. El rotulo dice como ESTA, no lo que hace el boton:
|
||||||
|
leer "dormido" y ver el punto apagado no deja lugar a dudas; "despertar"
|
||||||
|
obligaria a deducir si es lo que hace o lo que esta puesto. -->
|
||||||
|
<button data-accion="sueno" data-estado="on" class="secundario"
|
||||||
|
title="Atiende todo lo que oiga. Pulsa para exigir que le llames «JARVIS» antes de cada orden — util si hay una tele cerca">
|
||||||
|
<span class="punto"></span>
|
||||||
|
<span class="rotulo">escuchando</span>
|
||||||
|
</button>
|
||||||
|
|
||||||
|
<!-- Con que piensa. Se marca aparte cuando sale de la maquina: es el unico
|
||||||
|
boton del panel que cambia donde van a parar las palabras del usuario,
|
||||||
|
y eso no puede quedar escondido en un tooltip. -->
|
||||||
|
<button id="cerebro" class="secundario" title="Cambiar con que piensa JARVIS">
|
||||||
|
<span class="rotulo">cerebro</span>
|
||||||
|
</button>
|
||||||
|
|
||||||
|
<!-- Lanza varias acciones de verdad a la vez, para ver las tarjetas
|
||||||
|
trabajando sin tener que darle ordenes por voz. Es la forma de
|
||||||
|
comprobar de un vistazo que el panel hace lo que dice. -->
|
||||||
|
<button id="prueba" class="secundario" title="Lanza varias tareas reales a la vez para verlas trabajar">
|
||||||
|
<span class="rotulo">prueba</span>
|
||||||
|
</button>
|
||||||
|
</nav>
|
||||||
|
|
||||||
|
<!-- candado: tapa todo hasta que se teclea la contraseña -->
|
||||||
|
<div class="candado oculto" id="candado">
|
||||||
|
<div class="candado-caja">
|
||||||
|
<div class="candado-icono">▲</div>
|
||||||
|
<p class="candado-msg" id="candado-msg">Introduzca la contraseña</p>
|
||||||
|
<input id="candado-clave" type="password" autocomplete="off"
|
||||||
|
placeholder="Contraseña" autofocus>
|
||||||
|
<button id="candado-ok">Desbloquear</button>
|
||||||
|
</div>
|
||||||
|
</div>
|
||||||
|
|
||||||
|
<!-- el puente va antes: hud.js pregunta por window.webkit al cargarse -->
|
||||||
|
<script src="puente.js"></script>
|
||||||
|
<script src="hud.js"></script>
|
||||||
|
</body>
|
||||||
|
</html>
|
||||||
97
nucleo/cara/hud/puente.js
Normal file
97
nucleo/cara/hud/puente.js
Normal file
|
|
@ -0,0 +1,97 @@
|
||||||
|
/* El puente entre el HUD y el nucleo, por WebSocket.
|
||||||
|
*
|
||||||
|
* En la version sobre Newelle el HUD vivia dentro de un widget WebKit y hablaba
|
||||||
|
* por window.webkit.messageHandlers. Fuera del flatpak no hay tal widget, pero
|
||||||
|
* hud.js usa ese puente en ocho sitios y no merece la pena tocarlos: aqui se
|
||||||
|
* SUPLANTA window.webkit con un objeto que manda lo mismo por el socket.
|
||||||
|
*
|
||||||
|
* Asi hud.js se queda exactamente igual que estaba —cero diff sobre 2.064
|
||||||
|
* lineas que ya funcionaban— y ademas sigue abriendose suelto en un navegador
|
||||||
|
* para mirar el diseño, que es como se ha estado trabajando en el.
|
||||||
|
*
|
||||||
|
* Este fichero se carga ANTES que hud.js: cuando hud.js pregunte por
|
||||||
|
* window.webkit, ya esta.
|
||||||
|
*/
|
||||||
|
(function () {
|
||||||
|
"use strict";
|
||||||
|
|
||||||
|
// Ya estamos dentro de WebKit (queda de la epoca de Newelle): no tocar nada.
|
||||||
|
if (window.webkit && window.webkit.messageHandlers) return;
|
||||||
|
|
||||||
|
const URL = "ws://" + (location.host || "127.0.0.1:8790") + "/puente";
|
||||||
|
|
||||||
|
let socket = null;
|
||||||
|
let cola = []; // lo que se pulse antes de que abra el socket
|
||||||
|
let esperaReconexion = 500;
|
||||||
|
|
||||||
|
function manda(canal, dato) {
|
||||||
|
const mensaje = JSON.stringify({ canal: canal, dato: String(dato) });
|
||||||
|
if (socket && socket.readyState === WebSocket.OPEN) {
|
||||||
|
socket.send(mensaje);
|
||||||
|
} else {
|
||||||
|
// No se pierde: un boton pulsado mientras reconecta tiene que llegar
|
||||||
|
// igual, o el panel parece que se ha colgado. Con tope, que si el nucleo
|
||||||
|
// esta caido de verdad no queremos acumular mil pulsaciones.
|
||||||
|
if (cola.length < 50) cola.push(mensaje);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
// El mismo interfaz que ofrecia WebKit, para que hud.js no note el cambio.
|
||||||
|
window.webkit = {
|
||||||
|
messageHandlers: {
|
||||||
|
accion: { postMessage: (d) => manda("accion", d) },
|
||||||
|
listo: { postMessage: (d) => manda("listo", d) },
|
||||||
|
},
|
||||||
|
};
|
||||||
|
|
||||||
|
function conecta() {
|
||||||
|
try {
|
||||||
|
socket = new WebSocket(URL);
|
||||||
|
} catch (e) {
|
||||||
|
reintenta();
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
|
||||||
|
socket.addEventListener("open", () => {
|
||||||
|
esperaReconexion = 500;
|
||||||
|
marcaCaido(false);
|
||||||
|
const pendientes = cola;
|
||||||
|
cola = [];
|
||||||
|
pendientes.forEach((m) => socket.send(m));
|
||||||
|
});
|
||||||
|
|
||||||
|
socket.addEventListener("message", (ev) => {
|
||||||
|
let mensaje;
|
||||||
|
try {
|
||||||
|
mensaje = JSON.parse(ev.data);
|
||||||
|
} catch (e) {
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
// El formato {tipo, datos} es el mismo que empujaba Python por
|
||||||
|
// evaluate_javascript, asi que recibe() no cambia.
|
||||||
|
if (window.jarvis && window.jarvis.recibe) window.jarvis.recibe(mensaje);
|
||||||
|
});
|
||||||
|
|
||||||
|
socket.addEventListener("close", () => { marcaCaido(true); reintenta(); });
|
||||||
|
socket.addEventListener("error", () => { try { socket.close(); } catch (e) {} });
|
||||||
|
}
|
||||||
|
|
||||||
|
function reintenta() {
|
||||||
|
// Espera creciente hasta 8 s: reintentar cada 500 ms contra un nucleo
|
||||||
|
// parado calienta el portatil para nada.
|
||||||
|
setTimeout(conecta, esperaReconexion);
|
||||||
|
esperaReconexion = Math.min(esperaReconexion * 2, 8000);
|
||||||
|
}
|
||||||
|
|
||||||
|
// Que se vea que el panel esta hablando solo. Un HUD con datos congelados y
|
||||||
|
// sin avisar es peor que uno que dice claramente que perdio el hilo.
|
||||||
|
function marcaCaido(caido) {
|
||||||
|
document.documentElement.classList.toggle("sin-nucleo", caido);
|
||||||
|
}
|
||||||
|
|
||||||
|
if (document.readyState === "loading") {
|
||||||
|
document.addEventListener("DOMContentLoaded", conecta);
|
||||||
|
} else {
|
||||||
|
conecta();
|
||||||
|
}
|
||||||
|
})();
|
||||||
1233
nucleo/cara/hud/style.css
Normal file
1233
nucleo/cara/hud/style.css
Normal file
File diff suppressed because it is too large
Load diff
575
nucleo/cara/panel.py
Normal file
575
nucleo/cara/panel.py
Normal file
|
|
@ -0,0 +1,575 @@
|
||||||
|
"""Lo que une el nucleo con la cara: que se empuja al HUD y que se hace al pulsar.
|
||||||
|
|
||||||
|
`servidor.py` solo mueve bytes; aqui vive el significado. Es el equivalente de
|
||||||
|
lo que hacia `jarvis.py` dentro de Newelle —el fichero de 1.244 lineas que era
|
||||||
|
lo unico acoplado al framework— pero sin GTK, sin WebKit y sin el ciclo de vida
|
||||||
|
de la aplicacion de por medio.
|
||||||
|
|
||||||
|
## Lo que se empuja y cada cuanto
|
||||||
|
|
||||||
|
telemetria 1 s cpu, memoria, grafica, disco, procesos
|
||||||
|
pulso 15/s solo mientras escucha o habla; es lo que mueve el reactor
|
||||||
|
estado cuando cambia
|
||||||
|
tarea cuando cambia una
|
||||||
|
|
||||||
|
La telemetria cuesta procesos (`nvidia-smi`, `ps`), asi que va en su propio hilo
|
||||||
|
y a su ritmo, no en el bucle de voz. Y el pulso solo se manda si hay alguien
|
||||||
|
mirando: sin panel abierto son quince mensajes por segundo a nadie.
|
||||||
|
"""
|
||||||
|
import os
|
||||||
|
import shutil
|
||||||
|
import subprocess
|
||||||
|
import threading
|
||||||
|
import time
|
||||||
|
|
||||||
|
from manos.preguntar import confirmacion, es_si, pregunta_por
|
||||||
|
|
||||||
|
AQUI = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
|
||||||
|
|
||||||
|
|
||||||
|
def _lee(ruta, defecto=""):
|
||||||
|
try:
|
||||||
|
with open(ruta) as f:
|
||||||
|
return f.read().strip()
|
||||||
|
except OSError:
|
||||||
|
return defecto
|
||||||
|
|
||||||
|
|
||||||
|
def _manda(orden, tope=4000):
|
||||||
|
try:
|
||||||
|
r = subprocess.run(orden, capture_output=True, text=True, timeout=10)
|
||||||
|
return (r.stdout or "").strip()[:tope]
|
||||||
|
except (OSError, subprocess.TimeoutExpired):
|
||||||
|
return ""
|
||||||
|
|
||||||
|
|
||||||
|
class Telemetria:
|
||||||
|
"""Las constantes de la maquina, leidas baratas.
|
||||||
|
|
||||||
|
Todo de /proc salvo la grafica, que necesita nvidia-smi. Se lee /proc a
|
||||||
|
mano en vez de usar psutil para no arrastrar una dependencia por cuatro
|
||||||
|
numeros que estan en ficheros de texto.
|
||||||
|
"""
|
||||||
|
|
||||||
|
def __init__(self):
|
||||||
|
self._cpu_previo = None
|
||||||
|
self._nucleos_previo = None
|
||||||
|
self._hay_nvidia = shutil.which("nvidia-smi") is not None
|
||||||
|
|
||||||
|
def _cpu(self):
|
||||||
|
try:
|
||||||
|
with open("/proc/stat") as f:
|
||||||
|
lineas = [l for l in f if l.startswith("cpu")]
|
||||||
|
except OSError:
|
||||||
|
return 0, []
|
||||||
|
def uso(campos):
|
||||||
|
n = [int(x) for x in campos[1:11]]
|
||||||
|
ocupado = sum(n) - n[3] - n[4]
|
||||||
|
return ocupado, sum(n)
|
||||||
|
ahora = [uso(l.split()) for l in lineas]
|
||||||
|
previo, self._cpu_previo = self._cpu_previo, ahora
|
||||||
|
if not previo or len(previo) != len(ahora):
|
||||||
|
return 0, [0] * (len(ahora) - 1)
|
||||||
|
def pct(a, b):
|
||||||
|
d_ocu, d_tot = a[0] - b[0], a[1] - b[1]
|
||||||
|
return round(100 * d_ocu / d_tot) if d_tot > 0 else 0
|
||||||
|
return pct(ahora[0], previo[0]), [pct(a, b) for a, b in
|
||||||
|
zip(ahora[1:], previo[1:])]
|
||||||
|
|
||||||
|
def _memoria(self):
|
||||||
|
datos = {}
|
||||||
|
try:
|
||||||
|
with open("/proc/meminfo") as f:
|
||||||
|
for l in f:
|
||||||
|
k, _, v = l.partition(":")
|
||||||
|
datos[k] = int(v.split()[0]) // 1024 # MB
|
||||||
|
except OSError:
|
||||||
|
return 0, 0, 0, 0
|
||||||
|
total = datos.get("MemTotal", 0)
|
||||||
|
libre = datos.get("MemAvailable", 0)
|
||||||
|
stotal = datos.get("SwapTotal", 0)
|
||||||
|
slibre = datos.get("SwapFree", 0)
|
||||||
|
return total, total - libre, stotal, stotal - slibre
|
||||||
|
|
||||||
|
def _grafica(self):
|
||||||
|
if not self._hay_nvidia:
|
||||||
|
return None
|
||||||
|
s = _manda(["nvidia-smi",
|
||||||
|
"--query-gpu=utilization.gpu,memory.used,memory.total",
|
||||||
|
"--format=csv,noheader,nounits"])
|
||||||
|
try:
|
||||||
|
u, usada, total = (int(x.strip()) for x in s.split(",")[:3])
|
||||||
|
return {"uso": u, "usada": usada, "total": total}
|
||||||
|
except (ValueError, IndexError):
|
||||||
|
return None
|
||||||
|
|
||||||
|
def _temperatura(self):
|
||||||
|
mejor = 0
|
||||||
|
for zona in range(12):
|
||||||
|
t = _lee(f"/sys/class/thermal/thermal_zone{zona}/temp")
|
||||||
|
if t.isdigit():
|
||||||
|
mejor = max(mejor, int(t) // 1000)
|
||||||
|
return mejor
|
||||||
|
|
||||||
|
def _procesos(self, tope=5):
|
||||||
|
"""Los que mas CPU comen.
|
||||||
|
|
||||||
|
cpu y mem van como NUMEROS, no como las cadenas que devuelve ps. El HUD
|
||||||
|
hace `p.cpu.toFixed(0)`, y una cadena no tiene toFixed: la excepcion
|
||||||
|
aborta el manejador entero de telemetria y se lleva por delante todo lo
|
||||||
|
que se pinta despues —cpu, ram y grafica se quedaban en "--"—. El
|
||||||
|
sintoma no apuntaba a los procesos en absoluto.
|
||||||
|
"""
|
||||||
|
s = _manda(["ps", "-eo", "pid,comm,pcpu,pmem", "--sort=-pcpu"])
|
||||||
|
salida = []
|
||||||
|
for l in s.splitlines()[1:tope + 1]:
|
||||||
|
c = l.split(None, 3)
|
||||||
|
if len(c) < 4:
|
||||||
|
continue
|
||||||
|
try:
|
||||||
|
salida.append({"pid": int(c[0]), "nombre": c[1][:18],
|
||||||
|
"cpu": float(c[2]), "mem": float(c[3].split()[0])})
|
||||||
|
except ValueError:
|
||||||
|
continue
|
||||||
|
return salida
|
||||||
|
|
||||||
|
def _disco(self):
|
||||||
|
try:
|
||||||
|
st = os.statvfs("/")
|
||||||
|
total = st.f_blocks * st.f_frsize / 1e9
|
||||||
|
libre = st.f_bavail * st.f_frsize / 1e9
|
||||||
|
return round(total - libre, 1), round(total, 1)
|
||||||
|
except OSError:
|
||||||
|
return 0, 0
|
||||||
|
|
||||||
|
def _red(self):
|
||||||
|
"""Bytes acumulados por todas las interfaces menos la de loopback."""
|
||||||
|
baja = sube = 0
|
||||||
|
try:
|
||||||
|
with open("/proc/net/dev") as f:
|
||||||
|
for l in f.readlines()[2:]:
|
||||||
|
nombre, _, resto = l.partition(":")
|
||||||
|
if nombre.strip() == "lo":
|
||||||
|
continue
|
||||||
|
c = resto.split()
|
||||||
|
baja += int(c[0]); sube += int(c[8])
|
||||||
|
except (OSError, IndexError, ValueError):
|
||||||
|
return None
|
||||||
|
previo, self._red_previo = getattr(self, "_red_previo", None), (baja, sube, time.time())
|
||||||
|
if not previo:
|
||||||
|
return {"baja": 0, "sube": 0}
|
||||||
|
dt = max(self._red_previo[2] - previo[2], 0.001)
|
||||||
|
return {"baja": max(0, (baja - previo[0]) / dt),
|
||||||
|
"sube": max(0, (sube - previo[1]) / dt)}
|
||||||
|
|
||||||
|
def _bateria(self):
|
||||||
|
for n in range(3):
|
||||||
|
p = _lee(f"/sys/class/power_supply/BAT{n}/capacity")
|
||||||
|
if p.isdigit():
|
||||||
|
return int(p)
|
||||||
|
return None
|
||||||
|
|
||||||
|
def lee(self) -> dict:
|
||||||
|
"""Las unidades son las que espera el HUD, no las de /proc.
|
||||||
|
|
||||||
|
Se convierte aqui y no en JavaScript porque el formato lo fija la
|
||||||
|
pantalla: hud.js escribe "GB" y "TB" literalmente al lado del numero
|
||||||
|
(ponMedidor), asi que mandar megas se ve como "63488/64256 GB" y parece
|
||||||
|
que el panel esta roto cuando lo que esta mal es quien lo llena.
|
||||||
|
"""
|
||||||
|
cpu, nucleos = self._cpu()
|
||||||
|
mtotal, musada, stotal, susada = self._memoria()
|
||||||
|
dusado, dtotal = self._disco()
|
||||||
|
arriba = _lee("/proc/uptime", "0").split()[0]
|
||||||
|
datos = {
|
||||||
|
"cpu": cpu,
|
||||||
|
"nucleos": nucleos,
|
||||||
|
"ram": {"usada": musada / 1024, "total": mtotal / 1024}, # GB
|
||||||
|
"swap": {"usada": susada / 1024, "total": max(stotal / 1024, 0.01)},
|
||||||
|
"disco": {"usado": dusado / 1000, "total": dtotal / 1000}, # TB
|
||||||
|
"temperatura": self._temperatura(),
|
||||||
|
"carga": [float(x) for x in _lee("/proc/loadavg", "0 0 0").split()[:3]],
|
||||||
|
"uptime": float(arriba) if arriba else 0, # segundos
|
||||||
|
"procesos": self._procesos(),
|
||||||
|
}
|
||||||
|
g = self._grafica()
|
||||||
|
if g:
|
||||||
|
datos["gpu"] = {"uso": g["uso"],
|
||||||
|
"vram_usada": g["usada"] / 1024, # GB
|
||||||
|
"vram_total": g["total"] / 1024}
|
||||||
|
red = self._red()
|
||||||
|
if red:
|
||||||
|
datos["red"] = red
|
||||||
|
bat = self._bateria()
|
||||||
|
if bat is not None:
|
||||||
|
datos["bateria"] = bat
|
||||||
|
return datos
|
||||||
|
|
||||||
|
|
||||||
|
class Panel:
|
||||||
|
"""El nucleo visto desde la cara."""
|
||||||
|
|
||||||
|
def __init__(self, cara, boca, manos, cerebro=None, estado_voz=None,
|
||||||
|
candado=True, centinela=None):
|
||||||
|
self.cara = cara
|
||||||
|
self.boca = boca
|
||||||
|
self.manos = manos
|
||||||
|
self.cerebro = cerebro
|
||||||
|
self.centinela = centinela # quien decide si hay que llamarle
|
||||||
|
self.estado_voz = estado_voz # callable -> "escuchando"|"hablando"|...
|
||||||
|
self.telemetria = Telemetria()
|
||||||
|
self._parar = threading.Event()
|
||||||
|
|
||||||
|
# Las tarjetas: una por orden en marcha, con su reloj y su boton de
|
||||||
|
# parar. El prefijo va vacio porque aqui ya estamos en el host; dentro
|
||||||
|
# del flatpak era `flatpak-spawn --host --watch-bus`.
|
||||||
|
from manos.tareas import GestorTareas
|
||||||
|
self.tareas = GestorTareas(al_cambiar=self._tarea_cambio, prefijo_host=[])
|
||||||
|
|
||||||
|
# El candado. Tapa el panel y, sobre todo, hace que no obedezca: sin
|
||||||
|
# esto cualquiera que pase por delante del portatil abierto le puede
|
||||||
|
# dar ordenes a una maquina con sudo.
|
||||||
|
#
|
||||||
|
# La contraseña es la del sistema, comprobada con `sudo -S -v`, que NO
|
||||||
|
# ejecuta nada: solo valida. Asi no hay una contraseña propia que
|
||||||
|
# guardar en ningun sitio, que es una cosa menos que se puede filtrar.
|
||||||
|
self.candado = candado
|
||||||
|
self.desbloqueado = not candado
|
||||||
|
self._intentos = 0
|
||||||
|
|
||||||
|
# Lo que se ha preguntado y esta esperando respuesta hablada.
|
||||||
|
# (accion, para_que, hasta_cuando). para_que es "argumento" o "confirmar".
|
||||||
|
self.pendiente = None
|
||||||
|
|
||||||
|
# -------------------------------------------------------------- empujar
|
||||||
|
|
||||||
|
def arranca(self):
|
||||||
|
threading.Thread(target=self._bucle_telemetria, daemon=True).start()
|
||||||
|
if self.candado and not self.desbloqueado:
|
||||||
|
self.cara.manda("bloqueo", {"mensaje": "Introduzca la contraseña"})
|
||||||
|
self.manda_catalogo()
|
||||||
|
self.manda_controles()
|
||||||
|
self.cara.manda("voz", {"nombre": self.boca.voz, "id": self.boca.voz})
|
||||||
|
if self.cerebro:
|
||||||
|
self.cara.manda("cerebro", {"nombre": "local", "id": "local",
|
||||||
|
"detalle": self.cerebro.modelo,
|
||||||
|
"fuera": False})
|
||||||
|
|
||||||
|
def _bucle_telemetria(self):
|
||||||
|
tic = 0
|
||||||
|
while not self._parar.is_set():
|
||||||
|
# Sin nadie mirando no se gasta un nvidia-smi por segundo.
|
||||||
|
if self.cara.conectados:
|
||||||
|
try:
|
||||||
|
self.cara.manda("telemetria", self.telemetria.lee())
|
||||||
|
except Exception:
|
||||||
|
pass
|
||||||
|
# Las medidas de JARVIS (latencia, reparto, RAG) cambian mucho
|
||||||
|
# mas despacio que la CPU: se recalculan cada 5 s, no cada uno.
|
||||||
|
# Salen del diario, que es leer un fichero, no del sistema.
|
||||||
|
if tic % 5 == 0:
|
||||||
|
try:
|
||||||
|
from manos.medidas import lee_medidas
|
||||||
|
self.cara.manda("medidas", lee_medidas())
|
||||||
|
except Exception:
|
||||||
|
pass
|
||||||
|
tic += 1
|
||||||
|
self._parar.wait(1.0)
|
||||||
|
|
||||||
|
def manda_catalogo(self):
|
||||||
|
"""Lo que sabe hacer, agrupado, para la pestaña de la derecha."""
|
||||||
|
grupos = {}
|
||||||
|
for a in self.manos.catalogo.acciones:
|
||||||
|
if not a.frases:
|
||||||
|
continue
|
||||||
|
grupos.setdefault(a.grupo or "otras", []).append({
|
||||||
|
"id": a.id,
|
||||||
|
"frase": a.frases[0],
|
||||||
|
"argumento": a.captura,
|
||||||
|
"confirma": a.confirmar,
|
||||||
|
})
|
||||||
|
datos = [{"grupo": g, "acciones": v} for g, v in
|
||||||
|
sorted(grupos.items(), key=lambda x: -len(x[1]))]
|
||||||
|
self.cara.manda("catalogo", datos)
|
||||||
|
|
||||||
|
def _tarea_cambio(self, tarea):
|
||||||
|
"""Llamado desde el hilo de la tarea cada vez que hay algo que enseñar."""
|
||||||
|
try:
|
||||||
|
self.cara.manda("tarea", tarea.resumen())
|
||||||
|
except Exception:
|
||||||
|
pass
|
||||||
|
|
||||||
|
def lanza(self, accion, argumento=""):
|
||||||
|
"""Ejecuta una accion como TAREA, con tarjeta en el panel.
|
||||||
|
|
||||||
|
Se usa para lo que tarda. Lo instantaneo —el disco, la hora— no merece
|
||||||
|
una tarjeta: aparece, parpadea y se va antes de que nadie la lea.
|
||||||
|
"""
|
||||||
|
return self.tareas.lanza(accion, argumento)
|
||||||
|
|
||||||
|
def manda_controles(self):
|
||||||
|
"""El estado real de los interruptores, para que el rotulo no mienta.
|
||||||
|
|
||||||
|
Los botones NO se pintan al pulsarlos: se manda la orden y se espera a
|
||||||
|
que el nucleo conteste con como quedo. Asi el boton nunca dice
|
||||||
|
"despierto" con el centinela dormido.
|
||||||
|
"""
|
||||||
|
self.cara.manda("controles", {
|
||||||
|
# encendido = atiende todo; apagado = solo si le llaman
|
||||||
|
"sueno": not (self.centinela and self.centinela.activo),
|
||||||
|
})
|
||||||
|
|
||||||
|
def estado(self, cual: str):
|
||||||
|
self.cara.manda("estado", cual)
|
||||||
|
|
||||||
|
def dicho(self, texto: str, atendido=True, motivo=""):
|
||||||
|
"""Lo que se ha oido, SIEMPRE, tambien cuando se descarta.
|
||||||
|
|
||||||
|
Esto es lo que faltaba y por lo que el panel parecia muerto: se oia, se
|
||||||
|
transcribia, y si no llevaba la palabra de activacion se tiraba en
|
||||||
|
silencio. Desde la pantalla eso es indistinguible de un microfono
|
||||||
|
estropeado, y no hay forma de saber si el problema es que no te oye, que
|
||||||
|
te oye mal, o que te oye bien y no te hace caso.
|
||||||
|
|
||||||
|
El diccionario y no la cadena pelada: el HUD lee datos.texto.
|
||||||
|
"""
|
||||||
|
self.cara.manda("dicho", {"texto": texto, "atendido": atendido,
|
||||||
|
"motivo": motivo})
|
||||||
|
|
||||||
|
def respuesta(self, texto: str):
|
||||||
|
self.cara.manda("respuesta", {"texto": texto})
|
||||||
|
|
||||||
|
def para(self):
|
||||||
|
self._parar.set()
|
||||||
|
try:
|
||||||
|
self.tareas.para_todas()
|
||||||
|
except Exception:
|
||||||
|
pass
|
||||||
|
|
||||||
|
# --------------------------------------------------------------- pulsar
|
||||||
|
|
||||||
|
def pulsado(self, canal: str, dato: str):
|
||||||
|
"""Lo que llega del panel. Corre en su propio hilo, puede tardar."""
|
||||||
|
if canal == "listo":
|
||||||
|
self.arranca()
|
||||||
|
return
|
||||||
|
if canal != "accion":
|
||||||
|
return
|
||||||
|
|
||||||
|
# Desbloquear es lo unico que se atiende con el candado puesto.
|
||||||
|
if dato.startswith("desbloquear:"):
|
||||||
|
self._intenta_desbloquear(dato.split(":", 1)[1])
|
||||||
|
return
|
||||||
|
|
||||||
|
# Todo lo demas son ORDENES, y con el candado puesto no hay ordenes.
|
||||||
|
if self.candado and not self.desbloqueado:
|
||||||
|
self.cara.manda("bloqueo", {"mensaje": "Introduzca la contraseña"})
|
||||||
|
return
|
||||||
|
|
||||||
|
if dato == "voz:siguiente":
|
||||||
|
nueva = self.boca.siguiente()
|
||||||
|
self.cara.manda("voz", {"nombre": nueva, "id": nueva})
|
||||||
|
self.boca.di("Buenas noches, señor.")
|
||||||
|
|
||||||
|
elif dato == "prueba":
|
||||||
|
threading.Thread(target=self._tanda_de_prueba, daemon=True).start()
|
||||||
|
|
||||||
|
elif dato.startswith("explica:"):
|
||||||
|
self._explica(dato.split(":", 1)[1])
|
||||||
|
|
||||||
|
elif dato.startswith("parar_tarea:"):
|
||||||
|
self.tareas.para(dato.split(":", 1)[1])
|
||||||
|
|
||||||
|
elif dato.startswith("cerrar_tarea:"):
|
||||||
|
ident = dato.split(":", 1)[1]
|
||||||
|
self.tareas.cierra(ident)
|
||||||
|
self.cara.manda("tarea_fuera", {"id": ident})
|
||||||
|
|
||||||
|
elif dato == "sueno":
|
||||||
|
# Cambia si hace falta llamarle por su nombre.
|
||||||
|
#
|
||||||
|
# Por defecto NO hace falta: medido sobre 412 frases reales, el
|
||||||
|
# ruido ambiente no dispara nada, asi que exigir el nombre en cada
|
||||||
|
# frase era peaje sin contrapartida. El interruptor se queda para
|
||||||
|
# cuando haya una tele cerca.
|
||||||
|
if not self.centinela:
|
||||||
|
return
|
||||||
|
self.centinela.activo = not self.centinela.activo
|
||||||
|
if self.centinela.activo:
|
||||||
|
self.centinela.duerme()
|
||||||
|
self.boca.di_si_libre("Llameme por mi nombre, señor.")
|
||||||
|
else:
|
||||||
|
self.boca.di_si_libre("Le escucho, señor.")
|
||||||
|
self.manda_controles()
|
||||||
|
self.estado("escuchando" if not self.centinela.activo else "dormido")
|
||||||
|
|
||||||
|
elif dato.startswith("parar"):
|
||||||
|
# Cortar lo que este pasando AHORA: las tareas en marcha y la voz.
|
||||||
|
n = 0
|
||||||
|
for t in self.tareas.todas():
|
||||||
|
if t.estado == "corriendo" and self.tareas.para(t.id):
|
||||||
|
n += 1
|
||||||
|
self.boca.di_si_libre(f"Cortadas {n} tareas, señor." if n
|
||||||
|
else "No habia nada corriendo, señor.")
|
||||||
|
|
||||||
|
# Cuanto se espera la respuesta a una pregunta antes de darla por olvidada.
|
||||||
|
# Corto cansa —hay que pensar que fichero era—; largo hace que una frase
|
||||||
|
# suelta media conversacion despues se tome por la respuesta.
|
||||||
|
ESPERA_S = 45
|
||||||
|
|
||||||
|
def _explica(self, ident: str):
|
||||||
|
"""Pulsar una accion PREGUNTA lo que falta y la hace.
|
||||||
|
|
||||||
|
No recita la frase que la dispara. "Diga «busca el fichero» y a
|
||||||
|
continuacion lo que busca" es un manual de instrucciones, y uno pulsa
|
||||||
|
justo porque no quiere leerse el manual.
|
||||||
|
|
||||||
|
espera argumento -> pregunta cual y lo ejecuta con lo que digas
|
||||||
|
no tiene vuelta -> pide confirmacion antes
|
||||||
|
ninguna cosa -> la hace, que es a lo que has pulsado
|
||||||
|
|
||||||
|
Lo destructivo sigue sin dispararse de un clic: pasa por un si o un no
|
||||||
|
hablado, que es la misma red que tenia antes pero sin obligar a leer.
|
||||||
|
"""
|
||||||
|
accion = next((a for a in self.manos.catalogo.acciones if a.id == ident), None)
|
||||||
|
if accion is None:
|
||||||
|
return
|
||||||
|
|
||||||
|
if accion.captura:
|
||||||
|
self._pregunta(accion, "argumento", pregunta_por(accion))
|
||||||
|
elif accion.confirmar:
|
||||||
|
self._pregunta(accion, "confirmar", confirmacion(accion))
|
||||||
|
else:
|
||||||
|
self.tareas.lanza(accion, "")
|
||||||
|
|
||||||
|
def _pregunta(self, accion, para_que, texto, argumento=""):
|
||||||
|
self._argumento_pendiente = argumento
|
||||||
|
self.pendiente = (accion, para_que, time.monotonic() + self.ESPERA_S,
|
||||||
|
getattr(self, "_argumento_pendiente", ""))
|
||||||
|
self.cara.manda("preguntando", {"texto": texto, "accion": accion.id})
|
||||||
|
self.cara.manda("respuesta", {"texto": texto})
|
||||||
|
self.boca.di(texto)
|
||||||
|
|
||||||
|
def esperando(self):
|
||||||
|
"""La pregunta en el aire, o None si no hay o ya caduco."""
|
||||||
|
if not self.pendiente:
|
||||||
|
return None
|
||||||
|
if time.monotonic() > self.pendiente[2]:
|
||||||
|
self.olvida()
|
||||||
|
return None
|
||||||
|
return self.pendiente
|
||||||
|
|
||||||
|
def olvida(self):
|
||||||
|
self.pendiente = None
|
||||||
|
self.cara.manda("preguntando", {"texto": ""})
|
||||||
|
|
||||||
|
def responde(self, texto: str) -> bool:
|
||||||
|
"""Contesta a lo preguntado. Devuelve si consumio la frase.
|
||||||
|
|
||||||
|
Se llama desde el bucle de voz ANTES del emparejador: mientras hay una
|
||||||
|
pregunta en el aire, lo que se dice es la respuesta, no una orden nueva.
|
||||||
|
"""
|
||||||
|
pend = self.esperando()
|
||||||
|
if not pend:
|
||||||
|
return False
|
||||||
|
accion, para_que, _, argumento = pend
|
||||||
|
|
||||||
|
if para_que == "confirmar":
|
||||||
|
respuesta = es_si(texto)
|
||||||
|
if respuesta is None:
|
||||||
|
self.boca.di("No le he entendido. ¿Si o no, señor?")
|
||||||
|
return True
|
||||||
|
self.olvida()
|
||||||
|
if respuesta:
|
||||||
|
self.tareas.lanza(accion, argumento)
|
||||||
|
else:
|
||||||
|
self.boca.di("De acuerdo, lo dejo.")
|
||||||
|
return True
|
||||||
|
|
||||||
|
# argumento: cualquier cosa que no sea una cancelacion vale
|
||||||
|
if es_si(texto) is False:
|
||||||
|
self.olvida()
|
||||||
|
self.boca.di("De acuerdo, lo dejo.")
|
||||||
|
return True
|
||||||
|
self.olvida()
|
||||||
|
arg = texto.strip()
|
||||||
|
|
||||||
|
# Si ademas no tiene vuelta atras, se confirma AHORA que ya se sabe
|
||||||
|
# sobre que. Hay siete acciones que piden argumento y confirmacion
|
||||||
|
# —"mata el proceso", "que puertos tiene abiertos"— y preguntando solo
|
||||||
|
# el argumento se saltaban la red entera. Y confirmar antes de saber el
|
||||||
|
# argumento seria pedir un cheque en blanco: "¿mato el proceso?" "¿cual?"
|
||||||
|
if accion.confirmar:
|
||||||
|
self._pregunta(accion, "confirmar",
|
||||||
|
f"«{accion.frases[0]} {arg}». Esto no tiene vuelta "
|
||||||
|
f"atras. ¿Confirma, señor?", argumento=arg)
|
||||||
|
return True
|
||||||
|
|
||||||
|
self.tareas.lanza(accion, arg)
|
||||||
|
return True
|
||||||
|
|
||||||
|
def _intenta_desbloquear(self, clave: str):
|
||||||
|
if not clave:
|
||||||
|
return
|
||||||
|
# La misma GestorRoot de las manos: si la contraseña es buena, se queda
|
||||||
|
# ahi y el cerebro puede hacer sudo durante la sesion. Desbloquear el
|
||||||
|
# panel y abrir el root son el mismo gesto, con la misma contraseña.
|
||||||
|
try:
|
||||||
|
valida = self.manos.root.valida(clave)
|
||||||
|
except Exception as e:
|
||||||
|
self.cara.manda("bloqueo", {"mensaje": f"No se pudo comprobar: {e}",
|
||||||
|
"error": True})
|
||||||
|
return
|
||||||
|
|
||||||
|
if not valida:
|
||||||
|
self._intentos += 1
|
||||||
|
# Sin bloqueo por intentos ni espera creciente: la contraseña es la
|
||||||
|
# del sistema y quien la teclea esta sentado delante del portatil.
|
||||||
|
# Contarlos sirve para que el mensaje sea util, no para castigar.
|
||||||
|
self.cara.manda("bloqueo", {
|
||||||
|
"mensaje": "No es esa" + (f" ({self._intentos} intentos)"
|
||||||
|
if self._intentos > 1 else ""),
|
||||||
|
"error": True})
|
||||||
|
return
|
||||||
|
|
||||||
|
self._intentos = 0
|
||||||
|
self.desbloqueado = True
|
||||||
|
self.manos.root.recuerda(clave) # root disponible para la sesion
|
||||||
|
self.cara.manda("desbloqueado", True)
|
||||||
|
self.boca.di_si_libre("A su servicio, señor.")
|
||||||
|
|
||||||
|
def bloquea(self):
|
||||||
|
"""Echa el candado, aunque se arrancara sin el.
|
||||||
|
|
||||||
|
Que `--sin-candado` sea un arranque comodo no significa que uno no
|
||||||
|
pueda querer cerrarlo al levantarse de la silla. Por eso esto ACTIVA el
|
||||||
|
candado en vez de comprobar si estaba activo: negarse a cerrar porque
|
||||||
|
no estaba puesto seria justo lo contrario de lo que se pide.
|
||||||
|
"""
|
||||||
|
self.candado = True
|
||||||
|
self.desbloqueado = False
|
||||||
|
self._intentos = 0
|
||||||
|
self.manos.root.olvida() # y se cierra el root con el candado
|
||||||
|
self.cara.manda("bloqueo", {"mensaje": "Introduzca la contraseña"})
|
||||||
|
|
||||||
|
# Elegidas para que se vea el ciclo entero: una que acaba al instante, dos
|
||||||
|
# que tardan un poco, y una larga a la que da tiempo a pulsarle el boton de
|
||||||
|
# parar. Todas de solo lectura.
|
||||||
|
# Cada una comprobada contra el catalogo: una que no encaje no lanza
|
||||||
|
# tarjeta y la tanda queda coja sin decir por que.
|
||||||
|
PRUEBA = ["cuanto espacio queda", "cuanta memoria", "que temperatura hay",
|
||||||
|
"que esta consumiendo", "cuantos procesos hay"]
|
||||||
|
|
||||||
|
def _tanda_de_prueba(self):
|
||||||
|
"""Lanza varias a la vez para ver las tarjetas trabajando.
|
||||||
|
|
||||||
|
Van como TAREAS y no ejecutadas a pelo: el objetivo es justo ver el
|
||||||
|
ciclo entero —aparecer, contar segundos, terminar— y poder pulsarle el
|
||||||
|
boton de parar a la que tarda.
|
||||||
|
"""
|
||||||
|
for orden in self.PRUEBA:
|
||||||
|
accion, argumento = self.manos.busca(orden)
|
||||||
|
if accion is None:
|
||||||
|
continue
|
||||||
|
self.tareas.lanza(accion, argumento)
|
||||||
|
time.sleep(0.25)
|
||||||
173
nucleo/cara/servidor.py
Normal file
173
nucleo/cara/servidor.py
Normal file
|
|
@ -0,0 +1,173 @@
|
||||||
|
"""La cara: sirve el HUD y lo mantiene al dia por WebSocket.
|
||||||
|
|
||||||
|
## Por que un servidor y no una ventana
|
||||||
|
|
||||||
|
En Newelle el HUD era un widget WebKit dentro de la aplicacion. Sacandolo a un
|
||||||
|
servidor local se gana mas de lo que parece:
|
||||||
|
|
||||||
|
- el panel es una pagina normal: se abre con `chromium --app=`, en cualquier
|
||||||
|
navegador, o desde el movil o una tablet en la misma red;
|
||||||
|
- se puede mirar el diseño sin arrancar nada, que es como se ha trabajado en
|
||||||
|
el todo el tiempo;
|
||||||
|
- desaparece GTK de la cara, que era la ultima atadura al framework.
|
||||||
|
|
||||||
|
El formato de mensajes no cambia —{tipo, datos}, igual que empujaba Python por
|
||||||
|
evaluate_javascript— asi que `hud.js` se queda sin tocar. Lo unico nuevo es
|
||||||
|
`puente.js`, que suplanta `window.webkit` con el socket.
|
||||||
|
|
||||||
|
## Escucha solo en local
|
||||||
|
|
||||||
|
127.0.0.1 a proposito. Este panel ejecuta ordenes en la maquina: abrirlo a la
|
||||||
|
red seria dar una terminal a cualquiera del wifi. Para verlo desde el movil, un
|
||||||
|
tunel ssh, que ademas obliga a autenticarse.
|
||||||
|
"""
|
||||||
|
import asyncio
|
||||||
|
import json
|
||||||
|
import mimetypes
|
||||||
|
import os
|
||||||
|
import threading
|
||||||
|
|
||||||
|
HUD = os.path.join(os.path.dirname(os.path.abspath(__file__)), "hud")
|
||||||
|
PUERTO = int(os.environ.get("JARVIS_PUERTO", "8790"))
|
||||||
|
|
||||||
|
FICHEROS = {
|
||||||
|
"/": "index.html",
|
||||||
|
"/index.html": "index.html",
|
||||||
|
"/hud.js": "hud.js",
|
||||||
|
"/puente.js": "puente.js",
|
||||||
|
"/style.css": "style.css",
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
class Cara:
|
||||||
|
"""El panel: se le empujan eventos y devuelve lo que se pulsa."""
|
||||||
|
|
||||||
|
def __init__(self, al_pulsar=None, puerto=PUERTO):
|
||||||
|
self.al_pulsar = al_pulsar # (canal, dato) -> None
|
||||||
|
self.puerto = puerto
|
||||||
|
self._clientes = set()
|
||||||
|
self._bucle = None
|
||||||
|
self._hilo = None
|
||||||
|
self._ultimo = {} # el estado, para el que llegue tarde
|
||||||
|
|
||||||
|
# ------------------------------------------------------------- arrancar
|
||||||
|
|
||||||
|
def arranca(self):
|
||||||
|
"""Levanta el servidor en un hilo aparte y vuelve enseguida.
|
||||||
|
|
||||||
|
Devuelve la URL, o None si no se pudo. El motivo mas comun es que ya
|
||||||
|
haya otro JARVIS abierto: sin este manejo, el fallo salia como una traza
|
||||||
|
de asyncio dentro de un hilo, con "address already in use" enterrado en
|
||||||
|
la linea veinte, y el proceso seguia vivo sin panel.
|
||||||
|
"""
|
||||||
|
listo = threading.Event()
|
||||||
|
|
||||||
|
def corre():
|
||||||
|
self._bucle = asyncio.new_event_loop()
|
||||||
|
asyncio.set_event_loop(self._bucle)
|
||||||
|
try:
|
||||||
|
self._bucle.run_until_complete(self._sirve(listo))
|
||||||
|
except OSError as e:
|
||||||
|
self._error = e
|
||||||
|
listo.set()
|
||||||
|
return
|
||||||
|
self._bucle.run_forever()
|
||||||
|
|
||||||
|
self._error = None
|
||||||
|
self._hilo = threading.Thread(target=corre, daemon=True)
|
||||||
|
self._hilo.start()
|
||||||
|
listo.wait(timeout=10)
|
||||||
|
if self._error is not None:
|
||||||
|
import errno
|
||||||
|
if self._error.errno == errno.EADDRINUSE:
|
||||||
|
print(f" el puerto {self.puerto} ya esta cogido: ¿hay otro "
|
||||||
|
f"JARVIS abierto? (arranca.sh --stop, o JARVIS_PUERTO=otro)")
|
||||||
|
else:
|
||||||
|
print(f" no se pudo levantar el panel: {self._error}")
|
||||||
|
return None
|
||||||
|
return f"http://127.0.0.1:{self.puerto}/"
|
||||||
|
|
||||||
|
async def _sirve(self, listo):
|
||||||
|
import websockets
|
||||||
|
from websockets.http11 import Response
|
||||||
|
from websockets.datastructures import Headers
|
||||||
|
|
||||||
|
async def http(conexion, peticion):
|
||||||
|
"""Sirve los ficheros del HUD; deja pasar el WebSocket."""
|
||||||
|
ruta = peticion.path.split("?")[0]
|
||||||
|
if ruta == "/puente":
|
||||||
|
return None # que siga el apreton de manos
|
||||||
|
nombre = FICHEROS.get(ruta)
|
||||||
|
if not nombre:
|
||||||
|
return Response(404, "Not Found", Headers(), b"no esta\n")
|
||||||
|
try:
|
||||||
|
with open(os.path.join(HUD, nombre), "rb") as f:
|
||||||
|
cuerpo = f.read()
|
||||||
|
except OSError:
|
||||||
|
return Response(404, "Not Found", Headers(), b"no esta\n")
|
||||||
|
tipo = mimetypes.guess_type(nombre)[0] or "application/octet-stream"
|
||||||
|
cabeceras = Headers({
|
||||||
|
"Content-Type": tipo + ("; charset=utf-8" if "text" in tipo
|
||||||
|
or "javascript" in tipo else ""),
|
||||||
|
"Content-Length": str(len(cuerpo)),
|
||||||
|
# Sin cache: el HUD se edita en caliente y recargar tiene que
|
||||||
|
# traer lo nuevo, no lo de hace media hora.
|
||||||
|
"Cache-Control": "no-store",
|
||||||
|
})
|
||||||
|
return Response(200, "OK", cabeceras, cuerpo)
|
||||||
|
|
||||||
|
self._servidor = await websockets.serve(
|
||||||
|
self._cliente, "127.0.0.1", self.puerto, process_request=http)
|
||||||
|
listo.set()
|
||||||
|
|
||||||
|
# -------------------------------------------------------------- clientes
|
||||||
|
|
||||||
|
async def _cliente(self, ws):
|
||||||
|
self._clientes.add(ws)
|
||||||
|
try:
|
||||||
|
# Al conectar se le manda el estado que ya habia. Sin esto, abrir el
|
||||||
|
# panel a media sesion enseña un HUD vacio hasta que algo cambie.
|
||||||
|
for mensaje in self._ultimo.values():
|
||||||
|
await ws.send(json.dumps(mensaje))
|
||||||
|
async for crudo in ws:
|
||||||
|
try:
|
||||||
|
m = json.loads(crudo)
|
||||||
|
except json.JSONDecodeError:
|
||||||
|
continue
|
||||||
|
if self.al_pulsar:
|
||||||
|
# En otro hilo: atender una pulsacion puede tardar (hablar,
|
||||||
|
# cambiar de voz, lanzar una tarea) y el bucle del socket no
|
||||||
|
# puede quedarse esperando o el panel se congela entero.
|
||||||
|
threading.Thread(
|
||||||
|
target=self.al_pulsar,
|
||||||
|
args=(m.get("canal", ""), m.get("dato", "")),
|
||||||
|
daemon=True).start()
|
||||||
|
except Exception:
|
||||||
|
pass
|
||||||
|
finally:
|
||||||
|
self._clientes.discard(ws)
|
||||||
|
|
||||||
|
# --------------------------------------------------------------- empujar
|
||||||
|
|
||||||
|
def manda(self, tipo: str, datos):
|
||||||
|
"""Empuja un evento al panel. Se puede llamar desde cualquier hilo."""
|
||||||
|
mensaje = {"tipo": tipo, "datos": datos}
|
||||||
|
# Se recuerda lo ultimo de cada tipo salvo lo que caduca al instante:
|
||||||
|
# el pulso de la voz a 15 por segundo no tiene sentido reenviarlo.
|
||||||
|
if tipo not in ("pulso",):
|
||||||
|
self._ultimo[tipo] = mensaje
|
||||||
|
if not self._bucle or not self._clientes:
|
||||||
|
return
|
||||||
|
crudo = json.dumps(mensaje, ensure_ascii=False)
|
||||||
|
asyncio.run_coroutine_threadsafe(self._reparte(crudo), self._bucle)
|
||||||
|
|
||||||
|
async def _reparte(self, crudo):
|
||||||
|
for ws in list(self._clientes):
|
||||||
|
try:
|
||||||
|
await ws.send(crudo)
|
||||||
|
except Exception:
|
||||||
|
self._clientes.discard(ws)
|
||||||
|
|
||||||
|
@property
|
||||||
|
def conectados(self) -> int:
|
||||||
|
return len(self._clientes)
|
||||||
26
nucleo/cerebro/Modelfile
Normal file
26
nucleo/cerebro/Modelfile
Normal file
|
|
@ -0,0 +1,26 @@
|
||||||
|
# El modelo de JARVIS: qwen3.5 4B con parametros de asistente CONCISO.
|
||||||
|
#
|
||||||
|
# La build de qwen3.5 viene con temperature 1 y presence_penalty 1.5. Eso
|
||||||
|
# esta pensado para escritura creativa, no para un asistente de voz: el
|
||||||
|
# presence_penalty alto empuja al modelo a meter temas nuevos que no vienen a
|
||||||
|
# cuento —de ahi que acabara las frases soltando cuanta RAM queda— y la
|
||||||
|
# temperature alta lo hace divagar en vez de contestar y callar.
|
||||||
|
#
|
||||||
|
# Reconstruir: ollama create qwen3.5:4b-jarvis -f nucleo/cerebro/Modelfile
|
||||||
|
|
||||||
|
FROM qwen3.5:4b
|
||||||
|
|
||||||
|
# Bajo y estable: para "cuanto espacio queda" no hay creatividad que aportar,
|
||||||
|
# hay una cifra que dar.
|
||||||
|
PARAMETER temperature 0.4
|
||||||
|
# El que causaba el relleno. 0 = no penaliza repetir, asi que no siente la
|
||||||
|
# necesidad de introducir temas nuevos para variar.
|
||||||
|
PARAMETER presence_penalty 0.0
|
||||||
|
PARAMETER frequency_penalty 0.0
|
||||||
|
PARAMETER top_p 0.9
|
||||||
|
PARAMETER top_k 20
|
||||||
|
# Que pare cuando acabe la respuesta, no cuando se le acabe la cuerda.
|
||||||
|
PARAMETER num_predict 300
|
||||||
|
# 24 de 32 capas en la grafica: deja sitio a whisper en los 4 GB.
|
||||||
|
PARAMETER num_gpu 24
|
||||||
|
PARAMETER num_ctx 4096
|
||||||
0
nucleo/cerebro/__init__.py
Normal file
0
nucleo/cerebro/__init__.py
Normal file
316
nucleo/cerebro/ollama.py
Normal file
316
nucleo/cerebro/ollama.py
Normal file
|
|
@ -0,0 +1,316 @@
|
||||||
|
"""Pensar: hablar con ollama y dejarle usar las manos.
|
||||||
|
|
||||||
|
Newelle dedica 578 lineas a esto porque soporta quince motores distintos y
|
||||||
|
tiene que traducir el formato de herramientas de cada uno. Nosotros hablamos
|
||||||
|
solo con ollama, que trae tool calling nativo en `/api/chat`.
|
||||||
|
|
||||||
|
## Dos herramientas, no una
|
||||||
|
|
||||||
|
La primera version tenia una sola —"ejecuta una orden"— y salio mal de una
|
||||||
|
forma instructiva. Medido con tres modelos:
|
||||||
|
|
||||||
|
4B "abre una terminal" -> ejecuta_orden("xterm -e bash")
|
||||||
|
9B "cuanto espacio queda" -> ejecuta_orden("df -h / | grep ...")
|
||||||
|
9B "abre una terminal" -> ejecuta_orden("open -a Terminal") (¡macOS!)
|
||||||
|
|
||||||
|
Los modelos son serviciales: si les dejas un hueco donde cabe un comando, lo
|
||||||
|
escriben. Y el 9B, que es mas listo, lo hacia MAS —escribia pipelines enteras y
|
||||||
|
hasta ordenes de otro sistema operativo—.
|
||||||
|
|
||||||
|
La solucion no es rogarle al modelo en el prompt, es que el hueco no quepa. Se
|
||||||
|
parten en dos herramientas con fronteras claras:
|
||||||
|
|
||||||
|
`orden_del_catalogo` recibe castellano, se lo come el emparejador. La
|
||||||
|
descripcion lleva ejemplos REALES sacados del catalogo,
|
||||||
|
no inventados, y dice explicitamente que no acepta
|
||||||
|
comandos.
|
||||||
|
`comando_de_shell` para lo que no esta en el catalogo. Aqui SI se espera
|
||||||
|
un comando, asi que el modelo tiene donde poner lo que
|
||||||
|
queria poner, y deja de meterlo donde no toca.
|
||||||
|
|
||||||
|
## Por que el catalogo va antes que esto
|
||||||
|
|
||||||
|
Las 150 acciones se emparejan ANTES de llamar a ningun modelo. Esto solo se
|
||||||
|
usa para lo que no encaja —alrededor del 15 %— y para conversar. Por eso un
|
||||||
|
cerebro lento duele menos de lo que parece: la mayoria de las ordenes ni pasan
|
||||||
|
por aqui.
|
||||||
|
"""
|
||||||
|
import json
|
||||||
|
import os
|
||||||
|
import urllib.error
|
||||||
|
import urllib.request
|
||||||
|
|
||||||
|
ENDPOINT = os.environ.get("JARVIS_OLLAMA", "http://127.0.0.1:11434")
|
||||||
|
MODELO = os.environ.get("JARVIS_MODELO", "qwen3.5:4b-jarvis")
|
||||||
|
|
||||||
|
# Cuantas vueltas de "llama a una herramienta -> toma el resultado" se permiten
|
||||||
|
# antes de cortar. Sin tope, un modelo que se atasca pidiendo lo mismo deja al
|
||||||
|
# usuario esperando para siempre.
|
||||||
|
VUELTAS = 4
|
||||||
|
|
||||||
|
PERSONA = """Eres JARVIS, el asistente de voz de esta maquina.
|
||||||
|
|
||||||
|
REGLA QUE NO SE ROMPE NUNCA: no des ni un solo dato sobre este ordenador sin
|
||||||
|
haberlo comprobado antes con una herramienta. Ni el espacio del disco, ni la
|
||||||
|
memoria, ni cuantos ficheros hay, ni si algo esta abierto, ni la hora. Aunque
|
||||||
|
creas saberlo. Aunque parezca obvio. Si no lo has comprobado en esta misma
|
||||||
|
conversacion, lo compruebas.
|
||||||
|
|
||||||
|
Inventarse una cifra que suena razonable es el peor fallo que puedes cometer,
|
||||||
|
porque el usuario no tiene forma de saber que te la has inventado.
|
||||||
|
|
||||||
|
Y AL REVES: contesta SOLO lo que te preguntan. No añadas al final de tus
|
||||||
|
respuestas datos del sistema que nadie ha pedido —cuanta RAM queda, el espacio
|
||||||
|
del disco, la hora—. Si te preguntan como estas, "bien, señor" y punto; no lleva
|
||||||
|
un informe de memoria detras.
|
||||||
|
|
||||||
|
Para hacer algo, el orden es:
|
||||||
|
1. orden_del_catalogo, siempre que lo que te piden se parezca a algo de la
|
||||||
|
lista. Es lo que JARVIS sabe hacer bien y esta probado.
|
||||||
|
2. comando_de_shell solo si de verdad no esta en el catalogo.
|
||||||
|
|
||||||
|
Si te preguntan COMO se hace algo tecnico —una tecnica de pentesting, un flag,
|
||||||
|
una herramienta— y no lo tienes claro o no aparece en la documentacion de abajo,
|
||||||
|
usa buscar_en_apuntes con palabras clave ANTES de contestar. Ahi estan los
|
||||||
|
comandos que el usuario ya ha probado; es mejor buscarlos que inventarlos. Si la
|
||||||
|
primera busqueda no da, reformula y prueba otra vez.
|
||||||
|
|
||||||
|
Tu respuesta se convierte en AUDIO y se escucha en voz alta:
|
||||||
|
- Castellano siempre. Trata al usuario de usted y llamale "señor" en la primera
|
||||||
|
frase.
|
||||||
|
- Una o dos frases. Nada mas, salvo que te pidan detalle.
|
||||||
|
- Texto plano: ni asteriscos, ni vinetas, ni bloques de codigo, ni rutas largas.
|
||||||
|
- Los numeros redondeados y en palabras: "quedan setecientos gigas".
|
||||||
|
- Si algo falla, di en una frase QUE fallo. Sin disculpas de tres lineas.
|
||||||
|
|
||||||
|
Tienes acceso real a esta maquina y no estas en ningun contenedor. No digas
|
||||||
|
nunca que no puedes. En concreto, con comando_de_shell puedes:
|
||||||
|
- Ejecutar cualquier herramienta instalada, incluidas las de COFRE. Si no
|
||||||
|
recuerdas como se usa una, en la documentacion del usuario de abajo suele
|
||||||
|
estar el comando exacto.
|
||||||
|
- Conectarte a sus servidores: "ssh <host> '<comando>'" corre algo en el
|
||||||
|
servidor. Sus hosts estan en su configuracion; abajo veras cual encaja.
|
||||||
|
- Tareas de administrador, SOLO si el candado esta abierto. Si algo lo necesita
|
||||||
|
y no lo esta, dilo: que desbloquee y lo repites.
|
||||||
|
Antes de nada que borre datos o cambie el sistema, di lo que vas a hacer."""
|
||||||
|
|
||||||
|
|
||||||
|
def _ejemplos(catalogo, cuantos=8) -> str:
|
||||||
|
"""Ordenes de verdad del catalogo, repartidas entre grupos.
|
||||||
|
|
||||||
|
Van en la descripcion de la herramienta porque es lo unico que consigue que
|
||||||
|
el modelo pase castellano en vez de inventarse un comando. Salen del
|
||||||
|
catalogo y no escritas a mano para que no se queden viejas.
|
||||||
|
"""
|
||||||
|
por_grupo = {}
|
||||||
|
for a in catalogo.acciones:
|
||||||
|
if a.frases and not a.captura:
|
||||||
|
por_grupo.setdefault(a.grupo or "otras", []).append(a.frases[0])
|
||||||
|
muestra = []
|
||||||
|
grupos = list(por_grupo.values())
|
||||||
|
for i in range(cuantos):
|
||||||
|
for g in grupos:
|
||||||
|
if i < len(g) and len(muestra) < cuantos:
|
||||||
|
muestra.append(g[i])
|
||||||
|
return ", ".join(f'"{m}"' for m in muestra)
|
||||||
|
|
||||||
|
|
||||||
|
def herramientas(catalogo) -> list:
|
||||||
|
return [
|
||||||
|
{
|
||||||
|
"type": "function",
|
||||||
|
"function": {
|
||||||
|
"name": "orden_del_catalogo",
|
||||||
|
"description": (
|
||||||
|
"Ejecuta una de las ordenes que JARVIS ya sabe hacer. "
|
||||||
|
"Recibe la orden EN CASTELLANO, tal y como la diria una "
|
||||||
|
"persona. NO acepta comandos de shell: si escribes 'df -h' "
|
||||||
|
"o 'xterm' falla. Ejemplos validos: "
|
||||||
|
+ _ejemplos(catalogo) + ". "
|
||||||
|
"Usala siempre que puedas antes que el shell."
|
||||||
|
),
|
||||||
|
"parameters": {
|
||||||
|
"type": "object",
|
||||||
|
"properties": {
|
||||||
|
"orden": {
|
||||||
|
"type": "string",
|
||||||
|
"description": ("la orden en castellano, en palabras, "
|
||||||
|
"nunca un comando"),
|
||||||
|
}
|
||||||
|
},
|
||||||
|
"required": ["orden"],
|
||||||
|
},
|
||||||
|
},
|
||||||
|
},
|
||||||
|
{
|
||||||
|
"type": "function",
|
||||||
|
"function": {
|
||||||
|
"name": "buscar_en_apuntes",
|
||||||
|
"description": (
|
||||||
|
"Busca en los apuntes de pentesting y Linux del usuario (su "
|
||||||
|
"COFRE) el comando o la explicacion que necesites. Usala "
|
||||||
|
"cuando te pregunten COMO se hace algo tecnico —una tecnica, "
|
||||||
|
"un flag, una herramienta— y no lo tengas ya delante en la "
|
||||||
|
"documentacion. Puedes reformular la consulta con tus propias "
|
||||||
|
"palabras clave y buscar varias veces hasta dar con ello. "
|
||||||
|
"Devuelve los fragmentos mas parecidos, con su fuente, para "
|
||||||
|
"que respondas desde ahi y no de memoria."
|
||||||
|
),
|
||||||
|
"parameters": {
|
||||||
|
"type": "object",
|
||||||
|
"properties": {
|
||||||
|
"consulta": {
|
||||||
|
"type": "string",
|
||||||
|
"description": ("que buscar, en pocas palabras clave; "
|
||||||
|
"el nombre de la herramienta ayuda"),
|
||||||
|
}
|
||||||
|
},
|
||||||
|
"required": ["consulta"],
|
||||||
|
},
|
||||||
|
},
|
||||||
|
},
|
||||||
|
{
|
||||||
|
"type": "function",
|
||||||
|
"function": {
|
||||||
|
"name": "comando_de_shell",
|
||||||
|
"description": (
|
||||||
|
"Ejecuta un comando en la terminal de esta maquina, que es "
|
||||||
|
"Debian con GNOME. Solo para lo que NO esta en el catalogo. "
|
||||||
|
"Es de solo lectura: no ejecutes nada que borre o modifique "
|
||||||
|
"sin que te lo pidan expresamente."
|
||||||
|
),
|
||||||
|
"parameters": {
|
||||||
|
"type": "object",
|
||||||
|
"properties": {
|
||||||
|
"comando": {"type": "string",
|
||||||
|
"description": "el comando, para bash"},
|
||||||
|
},
|
||||||
|
"required": ["comando"],
|
||||||
|
},
|
||||||
|
},
|
||||||
|
},
|
||||||
|
]
|
||||||
|
|
||||||
|
|
||||||
|
class Cerebro:
|
||||||
|
def __init__(self, catalogo, modelo=MODELO, endpoint=ENDPOINT, en_ram=False,
|
||||||
|
manos=None):
|
||||||
|
self.catalogo = catalogo
|
||||||
|
self.modelo = modelo
|
||||||
|
self.endpoint = endpoint
|
||||||
|
# num_gpu 0 fuerza CPU: el modelo entero en RAM. Util para probar uno
|
||||||
|
# mas grande del que cabe en la grafica, a costa de velocidad.
|
||||||
|
self.capas = 0 if en_ram else None
|
||||||
|
self.manos = manos # a quien pedirle que ejecute
|
||||||
|
self.historia = []
|
||||||
|
|
||||||
|
def _saber(self, texto: str) -> str:
|
||||||
|
"""Los apuntes de COFRE que vengan a cuento, para meterlos al prompt.
|
||||||
|
|
||||||
|
Es la mitad "aumentar" de RAG: antes de contestar, se le pone delante al
|
||||||
|
modelo el trozo de los apuntes del usuario que mas se parece a lo que
|
||||||
|
pregunta. Asi construye la respuesta desde SU documentacion —flags
|
||||||
|
reales, comandos que ha probado— en vez de desde lo que recuerde, que
|
||||||
|
para 668 herramientas seria inventarselo.
|
||||||
|
|
||||||
|
Si no hay indice o nada encaja lo bastante, devuelve cadena vacia y el
|
||||||
|
prompt se queda como estaba: la funcion no puede empeorar una respuesta,
|
||||||
|
solo mejorarla.
|
||||||
|
"""
|
||||||
|
try:
|
||||||
|
from saber.busca import contexto, disponible
|
||||||
|
except Exception:
|
||||||
|
return ""
|
||||||
|
if not disponible():
|
||||||
|
return ""
|
||||||
|
trozos = contexto(texto, cuantos=4, minimo=0.38)
|
||||||
|
if not trozos:
|
||||||
|
return ""
|
||||||
|
return ("\n\n## Documentacion del usuario relevante a esto\n"
|
||||||
|
"Usa ESTO para responder, son sus apuntes probados. Si el "
|
||||||
|
"comando exacto esta aqui, dalo tal cual; no te inventes flags "
|
||||||
|
"que no aparezcan.\n\n" + trozos)
|
||||||
|
|
||||||
|
def _pide(self, mensajes, tools=None) -> dict:
|
||||||
|
cuerpo = {"model": self.modelo, "messages": mensajes, "stream": False,
|
||||||
|
"think": False, "options": {"temperature": 0.3}}
|
||||||
|
if tools:
|
||||||
|
cuerpo["tools"] = tools
|
||||||
|
if self.capas is not None:
|
||||||
|
cuerpo["options"]["num_gpu"] = self.capas
|
||||||
|
req = urllib.request.Request(
|
||||||
|
self.endpoint + "/api/chat", data=json.dumps(cuerpo).encode(),
|
||||||
|
headers={"Content-Type": "application/json"})
|
||||||
|
with urllib.request.urlopen(req, timeout=300) as r:
|
||||||
|
return json.loads(r.read())
|
||||||
|
|
||||||
|
def responde(self, texto: str, al_ejecutar=None) -> str:
|
||||||
|
"""Contesta, usando las manos si hace falta. Devuelve lo que hay que decir."""
|
||||||
|
self.historia.append({"role": "user", "content": texto})
|
||||||
|
sistema = PERSONA + self._saber(texto)
|
||||||
|
mensajes = [{"role": "system", "content": sistema}] + self.historia[-8:]
|
||||||
|
tools = herramientas(self.catalogo)
|
||||||
|
|
||||||
|
for _ in range(VUELTAS):
|
||||||
|
try:
|
||||||
|
d = self._pide(mensajes, tools)
|
||||||
|
except (urllib.error.URLError, OSError) as e:
|
||||||
|
return f"No he podido pensar, señor: {str(e)[:50]}"
|
||||||
|
|
||||||
|
m = d.get("message", {})
|
||||||
|
llamadas = m.get("tool_calls") or []
|
||||||
|
if not llamadas:
|
||||||
|
dicho = (m.get("content") or "").strip()
|
||||||
|
self.historia.append({"role": "assistant", "content": dicho})
|
||||||
|
return dicho
|
||||||
|
|
||||||
|
mensajes.append(m)
|
||||||
|
for lc in llamadas:
|
||||||
|
f = lc.get("function", {})
|
||||||
|
args = f.get("arguments") or {}
|
||||||
|
if isinstance(args, str):
|
||||||
|
try:
|
||||||
|
args = json.loads(args)
|
||||||
|
except json.JSONDecodeError:
|
||||||
|
args = {}
|
||||||
|
resultado = self._usa(f.get("name", ""), args, al_ejecutar)
|
||||||
|
mensajes.append({"role": "tool", "content": resultado[:2000]})
|
||||||
|
|
||||||
|
return "Me he liado dando vueltas, señor. Pruebe a pedirmelo de otra forma."
|
||||||
|
|
||||||
|
def _usa(self, nombre: str, args: dict, al_ejecutar=None) -> str:
|
||||||
|
# buscar_en_apuntes NO pasa por las manos: es lectura del indice, no
|
||||||
|
# toca la maquina, asi que funciona aunque el candado este echado.
|
||||||
|
if nombre == "buscar_en_apuntes":
|
||||||
|
return self._busca_apuntes(args.get("consulta", ""))
|
||||||
|
if self.manos is None:
|
||||||
|
return "no hay manos conectadas"
|
||||||
|
if nombre == "orden_del_catalogo":
|
||||||
|
return self.manos.por_orden(args.get("orden", ""), al_ejecutar)
|
||||||
|
if nombre == "comando_de_shell":
|
||||||
|
return self.manos.por_shell(args.get("comando", ""), al_ejecutar)
|
||||||
|
return f"no existe la herramienta {nombre}"
|
||||||
|
|
||||||
|
def _busca_apuntes(self, consulta: str) -> str:
|
||||||
|
"""El RAG como herramienta: el modelo busca cuando lo decide.
|
||||||
|
|
||||||
|
La inyeccion pasiva de _saber() usa la frase LITERAL del usuario y
|
||||||
|
dispara siempre. Esto es lo otro: el modelo reformula la consulta con
|
||||||
|
sus palabras y busca a proposito, que es lo que salva los casos donde el
|
||||||
|
usuario dice una cosa y el apunte esta escrito de otra."""
|
||||||
|
consulta = (consulta or "").strip()
|
||||||
|
if not consulta:
|
||||||
|
return "dime que buscar"
|
||||||
|
try:
|
||||||
|
from saber.busca import busca
|
||||||
|
except Exception:
|
||||||
|
return "no tengo los apuntes indexados"
|
||||||
|
trozos = [t for t in busca(consulta, cuantos=5) if t.get("sim", 0) >= 0.3]
|
||||||
|
if not trozos:
|
||||||
|
return ("no encontre nada en los apuntes sobre eso; prueba con otras "
|
||||||
|
"palabras o el nombre de la herramienta")
|
||||||
|
lineas = []
|
||||||
|
for t in trozos:
|
||||||
|
fuente = t.get("fichero") or f"{t.get('perfil')}/{t.get('herramienta')}"
|
||||||
|
lineas.append(f"[{fuente}]\n{t['texto'][:500]}")
|
||||||
|
return "\n\n".join(lineas)
|
||||||
468
nucleo/datos/_generar.py
Normal file
468
nucleo/datos/_generar.py
Normal file
|
|
@ -0,0 +1,468 @@
|
||||||
|
#!/usr/bin/env python3
|
||||||
|
"""Genera acciones.json.
|
||||||
|
|
||||||
|
Se escribe aqui y no a mano en el JSON porque son mas de cien entradas con la
|
||||||
|
misma forma: en tabla se leen de un tirón y se ve si falta un acuse o si dos
|
||||||
|
frases chocan. El JSON es el producto; este fichero es la fuente.
|
||||||
|
|
||||||
|
python3 _generar.py && python3 -m json.tool acciones.json >/dev/null
|
||||||
|
|
||||||
|
Columnas: id | frases (| separadas) | acuse | comando | respuesta
|
||||||
|
|
||||||
|
Reglas que conviene no romper:
|
||||||
|
- Las frases van sin tildes ni signos: el motor normaliza lo que oye, pero
|
||||||
|
aqui se comparan tal cual.
|
||||||
|
- Frases cortas y genericas ("abre") arrastran todo lo demas; se prefieren
|
||||||
|
de tres palabras o mas, que es como se habla de verdad.
|
||||||
|
- Todo lo que borre, mate o apague lleva confirmar=True.
|
||||||
|
- {argumento} solo en las que declaran captura.
|
||||||
|
"""
|
||||||
|
import json
|
||||||
|
import pathlib
|
||||||
|
|
||||||
|
# --------------------------------------------------------------- sistema
|
||||||
|
SISTEMA = [
|
||||||
|
("disco_libre", "cuanto espacio queda|espacio en disco|espacio libre en disco|cuanto disco queda",
|
||||||
|
"Un momento, lo miro.", "df -h / | tail -1",
|
||||||
|
"Quedan {campo4} libres de {campo2}, al {campo5} de uso."),
|
||||||
|
("disco_home", "como esta mi disco|cuanto ocupa mi disco|espacio de mi disco",
|
||||||
|
"Un momento.", "df -h ~ | tail -1",
|
||||||
|
"Su disco esta al {campo5}, con {campo4} libres de {campo2}."),
|
||||||
|
("disco_todos", "discos montados|particiones|unidades montadas",
|
||||||
|
"Enseguida.", "df -h --output=target,size,pcent -x tmpfs -x devtmpfs | tail -n +2",
|
||||||
|
"Hay {lineas} unidades montadas. {salida}"),
|
||||||
|
("memoria", "cuanta memoria|memoria libre|cuanta ram|ram libre",
|
||||||
|
"Voy.", "free -g | awk '/Mem:/{print $2, $3, $7}'",
|
||||||
|
"De {campo1} gigas hay {campo2} en uso y {campo3} disponibles."),
|
||||||
|
("swap", "como esta la swap|memoria de intercambio",
|
||||||
|
"Voy.", "free -g | awk '/Swap:/{print $2, $3}'",
|
||||||
|
"Swap: {campo2} gigas usados de {campo1}."),
|
||||||
|
("cpu_carga", "carga del sistema|como va el procesador|carga de cpu",
|
||||||
|
"Un segundo.", "uptime | sed 's/.*average: //'",
|
||||||
|
"La carga media es {ultima}."),
|
||||||
|
("cpu_modelo", "que procesador tengo|modelo de procesador|que cpu tengo",
|
||||||
|
"Enseguida.", "lscpu | grep 'Model name' | cut -d: -f2 | xargs",
|
||||||
|
"Lleva un {ultima}."),
|
||||||
|
("cpu_nucleos", "cuantos nucleos tengo|cuantos hilos tengo",
|
||||||
|
"Voy.", "nproc", "Tiene {ultima} hilos disponibles."),
|
||||||
|
("temperatura", "que temperatura hay|como esta de temperatura|se esta calentando",
|
||||||
|
"Lo compruebo.", "for z in /sys/class/thermal/thermal_zone*/temp; do cat $z; done | sort -rn | head -1 | awk '{printf \"%.0f\", $1/1000}'",
|
||||||
|
"El punto mas caliente esta a {ultima} grados."),
|
||||||
|
("gpu_estado", "como esta la grafica|estado de la gpu|uso de la grafica",
|
||||||
|
"Un momento.",
|
||||||
|
"nvidia-smi --query-gpu=utilization.gpu,memory.used,memory.total,temperature.gpu --format=csv,noheader",
|
||||||
|
"La grafica esta asi: {ultima}."),
|
||||||
|
("uptime", "cuanto lleva encendido|desde cuando esta encendido|tiempo encendido",
|
||||||
|
"Voy.", "uptime -p | sed 's/^up //; s/ days\\?/ dias/; s/ hours\\?/ horas/; s/ minutes\\?/ minutos/; s/,\\([^,]*\\)$/ y\\1/'",
|
||||||
|
"Lleva encendido {ultima}."),
|
||||||
|
("bateria", "cuanta bateria queda|como esta la bateria|nivel de bateria",
|
||||||
|
"Lo miro.", "cat /sys/class/power_supply/BAT*/capacity 2>/dev/null | head -1",
|
||||||
|
"La bateria esta al {ultima} por ciento."),
|
||||||
|
("kernel", "que kernel tengo|version del kernel|que nucleo tengo",
|
||||||
|
"Enseguida.", "uname -r", "Kernel {ultima}."),
|
||||||
|
("distro", "que distribucion tengo|que sistema tengo|que linux tengo",
|
||||||
|
"Voy.", "grep PRETTY_NAME /etc/os-release | cut -d'\"' -f2",
|
||||||
|
"Esta usando {ultima}."),
|
||||||
|
("fecha", "que hora es|que dia es|dime la fecha",
|
||||||
|
"", "date '+%H:%M del %A %d de %B'", "Son las {salida}."),
|
||||||
|
("procesos_top", "que esta consumiendo|que consume mas|procesos que mas gastan|quien se come la cpu",
|
||||||
|
"Lo compruebo.", "ps -eo pcpu,comm --sort=-pcpu --no-headers | head -5 | awk '{c=$1; $1=\"\"; sub(/^ +/,\"\"); printf \"%s al %s por ciento\\n\", $0, c}'",
|
||||||
|
"Lo que mas consume es {primera}."),
|
||||||
|
("procesos_memoria", "que consume mas memoria|quien se come la ram",
|
||||||
|
"Lo compruebo.", "ps -eo comm,pmem --sort=-pmem --no-headers | head -5",
|
||||||
|
"Por memoria: {salida}"),
|
||||||
|
("procesos_cuantos", "cuantos procesos hay|cuantos procesos corren",
|
||||||
|
"Voy.", "ps -e --no-headers | wc -l", "Hay {ultima} procesos en marcha."),
|
||||||
|
("red_ip", "cual es mi ip|mi ip local|que ip tengo",
|
||||||
|
"Un momento.", "hostname -I | awk '{print $1}'", "Su IP local es {ultima}."),
|
||||||
|
("red_ip_publica", "cual es mi ip publica|ip externa",
|
||||||
|
"Salgo a mirarlo.", "curl -s --max-time 6 ifconfig.me", "Su IP publica es {ultima}."),
|
||||||
|
("red_wifi", "a que wifi estoy conectado|red wifi|como se llama la wifi",
|
||||||
|
"Voy.", "nmcli -t -f NAME,TYPE connection show --active | grep wireless | cut -d: -f1",
|
||||||
|
"Conectado a {ultima}."),
|
||||||
|
("red_velocidad", "cuanto trafico de red|trafico de red",
|
||||||
|
"Lo miro.", "cat /proc/net/dev | awk '/wlp|enp/{rx+=$2; tx+=$10} END{printf \"%.1f %.1f\", rx/1e9, tx/1e9}'",
|
||||||
|
"Desde el arranque: {campo1} gigas bajados y {campo2} subidos."),
|
||||||
|
("red_ping", "hay internet|tengo conexion|funciona internet",
|
||||||
|
"Lo compruebo.",
|
||||||
|
"ping -c1 -W2 1.1.1.1 >/dev/null 2>&1 && echo si || echo no",
|
||||||
|
"Conexion: {ultima}."),
|
||||||
|
("puertos", "que puertos hay abiertos|puertos a la escucha|quien esta escuchando",
|
||||||
|
"Un momento.", "ss -ltnp 2>/dev/null | awk 'NR>1{print $4}' | sort -u | head -8",
|
||||||
|
"A la escucha: {salida}"),
|
||||||
|
("servicios_fallidos", "hay servicios caidos|servicios con fallos|algo ha fallado",
|
||||||
|
"Lo reviso.", "systemctl --failed --no-legend | wc -l",
|
||||||
|
"Servicios en fallo: {ultima}."),
|
||||||
|
("actualizaciones", "hay actualizaciones|paquetes por actualizar",
|
||||||
|
"Lo compruebo, tarda un poco.",
|
||||||
|
"apt list --upgradable 2>/dev/null | tail -n +2 | wc -l",
|
||||||
|
"Hay {ultima} paquetes por actualizar."),
|
||||||
|
("usuarios", "quien esta conectado|hay alguien conectado",
|
||||||
|
"Voy.", "who | wc -l", "Hay {ultima} sesiones abiertas."),
|
||||||
|
("gpu_procesos", "que usa la grafica|quien usa la gpu",
|
||||||
|
"Lo miro.", "O=$(nvidia-smi --query-compute-apps=process_name,used_gpu_memory --format=csv,noheader | awk -F, '{n=split($1,p,\"/\"); printf \"%s%s\\n\", p[n], $2}'); echo \"${O:-nada, la grafica esta libre}\"",
|
||||||
|
"En la grafica: {primera}"),
|
||||||
|
("audio_salida", "por donde suena|salida de audio|que altavoz esta puesto",
|
||||||
|
"Voy.", "pactl get-default-sink 2>/dev/null", "La salida es {ultima}."),
|
||||||
|
("audio_micro", "que microfono hay puesto|entrada de audio",
|
||||||
|
"Voy.", "pactl get-default-source 2>/dev/null", "La entrada es {ultima}."),
|
||||||
|
("pantallas", "cuantas pantallas hay|monitores conectados",
|
||||||
|
"Voy.", "n=$(xrandr --listmonitors 2>/dev/null | head -1 | awk '{print $2}'); xrandr --listmonitors 2>/dev/null | tail -n +2 | awk '{print $NF}' | paste -sd', '; echo \"Tiene $n pantalla$([ \"$n\" = 1 ] || echo s) conectada$([ \"$n\" = 1 ] || echo s)\"",
|
||||||
|
"{ultima}"),
|
||||||
|
("dispositivos_usb", "que hay conectado por usb|dispositivos usb",
|
||||||
|
"Un momento.", "lsusb | cut -d' ' -f7- | head -6", "Por USB: {salida}"),
|
||||||
|
("bluetooth", "que hay emparejado por bluetooth|dispositivos bluetooth",
|
||||||
|
"Voy.", "bluetoothctl devices 2>/dev/null | cut -d' ' -f3- | head -5",
|
||||||
|
"Emparejados: {salida}"),
|
||||||
|
("flatpaks", "que flatpaks tengo|aplicaciones flatpak",
|
||||||
|
"Voy.", "flatpak list --app --columns=name | head -10", "Instalados: {salida}"),
|
||||||
|
("docker", "hay contenedores corriendo|contenedores docker",
|
||||||
|
"Lo miro.", "O=$(docker ps --format '{{.Names}}' 2>/dev/null | head -5); echo \"${O:-ninguno en marcha}\"",
|
||||||
|
"Contenedores: {salida}"),
|
||||||
|
("git_estado", "como esta el repositorio|estado de git",
|
||||||
|
"Voy.", "cd ~/COFRE/CODERS/JARVIS && git status --short | wc -l",
|
||||||
|
"Hay {ultima} ficheros con cambios sin guardar."),
|
||||||
|
("ollama_estado", "esta ollama funcionando|como esta el modelo|que modelo hay cargado",
|
||||||
|
"Lo compruebo.",
|
||||||
|
"M=$(curl -s --max-time 3 http://localhost:11434/api/ps | grep -o '\"name\":\"[^\"]*' | cut -d'\"' -f4 | head -1); echo \"${M:-ninguno ahora mismo}\"",
|
||||||
|
"Modelo cargado: {ultima}."),
|
||||||
|
("apagar_pantalla", "apaga la pantalla|apagar pantalla",
|
||||||
|
"Enseguida.", "xset dpms force off", "Pantalla apagada."),
|
||||||
|
# --- administracion: necesitan root, disparan el dialogo de contraseña ---
|
||||||
|
# (Las de pentesting van en su propia lista, PENTEST, mas abajo.)
|
||||||
|
("actualizar_lista", "actualiza los repositorios|refresca los paquetes|actualiza la lista de paquetes",
|
||||||
|
"Voy, necesito permiso de administrador.", "sudo apt update",
|
||||||
|
"Repositorios actualizados, señor.", True),
|
||||||
|
("espacio_liberar", "limpia los paquetes viejos|libera espacio de apt|limpia el cache de paquetes",
|
||||||
|
"Necesito permiso para esto.", "sudo apt autoclean",
|
||||||
|
"Cache de paquetes limpiada, señor.", True),
|
||||||
|
("servicio_reiniciar", "reinicia el servicio de red|reinicia la red",
|
||||||
|
"Necesito permiso de administrador.", "sudo systemctl restart NetworkManager",
|
||||||
|
"Red reiniciada, señor.", True),
|
||||||
|
("fecha_sincronizar", "sincroniza la hora|pon la hora en hora",
|
||||||
|
"Un momento, con permiso.", "sudo systemctl restart systemd-timesyncd",
|
||||||
|
"Hora sincronizada, señor.", True),
|
||||||
|
("bloquear", "bloquea la sesion|bloquear pantalla|echa el cerrojo",
|
||||||
|
"Ahora mismo.", "loginctl lock-session", "Sesion bloqueada."),
|
||||||
|
("volumen_subir", "sube el volumen|mas volumen",
|
||||||
|
"", "pactl set-sink-volume @DEFAULT_SINK@ +10%", "Volumen subido."),
|
||||||
|
("volumen_bajar", "baja el volumen|menos volumen",
|
||||||
|
"", "pactl set-sink-volume @DEFAULT_SINK@ -10%", "Volumen bajado."),
|
||||||
|
("volumen_silencio", "silencia el sistema|quita el sonido|mutea el sistema",
|
||||||
|
"", "pactl set-sink-mute @DEFAULT_SINK@ toggle", "Sonido conmutado."),
|
||||||
|
("brillo_subir", "sube el brillo|mas brillo",
|
||||||
|
"", "brightnessctl set +10% 2>/dev/null || xrandr --output $(xrandr | awk '/ connected/{print $1; exit}') --brightness 1",
|
||||||
|
"Brillo subido."),
|
||||||
|
("captura_pantalla", "hazme una captura|captura de pantalla|haz una foto de la pantalla",
|
||||||
|
"Enseguida se la hago.", "D=$(xdg-user-dir PICTURES 2>/dev/null || echo ~); F=$D/captura-$(date +%H%M%S).png; import -window root \"$F\" 2>/dev/null || gnome-screenshot -f \"$F\" 2>/dev/null || ffmpeg -loglevel error -f x11grab -video_size $(xdpyinfo | awk \"/dimensions/{print \\$2}\") -i $DISPLAY -frames:v 1 -y \"$F\" 2>/dev/null; [ -s \"$F\" ] && echo \"$F\"",
|
||||||
|
"Captura guardada."),
|
||||||
|
("papelera_tamano", "cuanto ocupa la papelera|papelera llena",
|
||||||
|
"Voy.", "du -sh ~/.local/share/Trash 2>/dev/null | cut -f1",
|
||||||
|
"La papelera ocupa {ultima}."),
|
||||||
|
("descargas_listar", "que hay en descargas|ultimas descargas|que me he bajado",
|
||||||
|
"Voy.", "ls -t ~/Downloads 2>/dev/null | head -6", "Hay {lineas} cosas en descargas"),
|
||||||
|
("descargas_abrir", "abre la carpeta de descargas|abreme descargas",
|
||||||
|
"Enseguida se la abro.", "xdg-open ~/Downloads", "Carpeta de descargas abierta."),
|
||||||
|
("documentos_abrir", "abre mis documentos|abreme documentos",
|
||||||
|
"Enseguida.", "xdg-open ~/Documents", "Documentos abierto."),
|
||||||
|
("cofre_abrir", "abre el cofre|abreme el cofre",
|
||||||
|
"Enseguida.", "xdg-open ~/COFRE", "COFRE abierto."),
|
||||||
|
("ficheros_recientes", "que he tocado ultimamente|ficheros recientes|en que estaba trabajando",
|
||||||
|
"Lo miro.",
|
||||||
|
"find ~ -maxdepth 3 -type f -mmin -180 -not -path '*/.*' 2>/dev/null | head -6",
|
||||||
|
"Tocado en las ultimas horas: {salida}"),
|
||||||
|
("grandes", "que ocupa mas sitio|que tengo en descargas|que me esta llenando la carpeta",
|
||||||
|
"Lo miro.",
|
||||||
|
"du -ah ~/Downloads ~/Descargas ~/Documents ~/Desktop 2>/dev/null | sort -rh | head -6",
|
||||||
|
"Lo mas grande: {salida}"),
|
||||||
|
]
|
||||||
|
|
||||||
|
# ------------------------------------------------------- con argumento
|
||||||
|
CAPTURA = [
|
||||||
|
("buscar_fichero", "busca el fichero|buscame el fichero|encuentra el fichero",
|
||||||
|
"Lo busco.", "timeout 12 find $HOME/Documents $HOME/Desktop $HOME/COFRE/CODERS $HOME/Downloads -iname '*{argumento}*' -not -path '*/.*' -not -path '*/node_modules/*' -not -path '*venv*' 2>/dev/null | head -12",
|
||||||
|
"He encontrado {lineas}"),
|
||||||
|
("buscar_carpeta", "busca la carpeta|encuentra la carpeta",
|
||||||
|
"La busco.", "find ~ -type d -iname '*{argumento}*' -not -path '*/.*' 2>/dev/null | head -12",
|
||||||
|
"Carpetas encontradas: {salida}"),
|
||||||
|
# busca un TEXTO dentro de los ficheros, recursivo, con ruta y linea
|
||||||
|
("grep_recursivo", "busca el texto|busca la palabra en mis ficheros|donde pone|que fichero contiene",
|
||||||
|
"Lo busco en sus ficheros.", "timeout 12 grep -rIn --exclude-dir='.*' --exclude-dir='*venv*' --exclude-dir=node_modules --exclude-dir=__pycache__ --exclude-dir=modelos --exclude-dir=muestras -m1 {argumento} $HOME/Documents $HOME/Desktop $HOME/COFRE/CODERS 2>/dev/null | head -12",
|
||||||
|
"{lineas} ficheros lo contienen."),
|
||||||
|
("leer_fichero", "leeme el fichero|abre y leeme|lee el fichero",
|
||||||
|
"Voy a leerlo.", "f=$(timeout 12 find $HOME/Documents $HOME/Desktop $HOME/COFRE/CODERS -iname '*{argumento}*' -type f -not -path '*/.*' 2>/dev/null | head -1); [ -n \"$f\" ] && head -c 800 \"$f\" || echo \"no lo encuentro\"",
|
||||||
|
"{salida}, señor"),
|
||||||
|
("abrir_fichero", "abre el fichero|abreme el fichero",
|
||||||
|
"Enseguida se lo abro.",
|
||||||
|
"f=$(find ~ -iname '*{argumento}*' -type f -not -path '*/.*' 2>/dev/null | head -1); "
|
||||||
|
"[ -n \"$f\" ] && xdg-open \"$f\" && echo \"$f\" || echo 'no lo encuentro'",
|
||||||
|
"Abierto {ultima}."),
|
||||||
|
("abrir_carpeta", "abre la carpeta|abreme la carpeta",
|
||||||
|
"Enseguida.", "a={argumento}; if [ -d \"$a\" ]; then d=\"$a\"; else d=$(timeout 12 find $HOME/Documents $HOME/Desktop $HOME/COFRE $HOME/Downloads -type d -iname \"*$a*\" -not -path \"*/.*\" -not -path \"*/node_modules/*\" 2>/dev/null | head -1); fi; if [ -n \"$d\" ]; then xdg-open \"$d\" >/dev/null 2>&1 & echo \"Abierta $(basename \"$d\")\"; else echo \"No encuentro esa carpeta\"; fi",
|
||||||
|
"{ultima}"),
|
||||||
|
("tamano_carpeta", "cuanto ocupa la carpeta|tamaño de la carpeta",
|
||||||
|
"Lo calculo.",
|
||||||
|
"a={argumento}; if [ -d \"$a\" ]; then d=\"$a\"; else d=$(timeout 12 find $HOME/Documents $HOME/Desktop $HOME/COFRE $HOME/Downloads -type d -iname \"*$a*\" -not -path \"*/.*\" 2>/dev/null | head -1); fi; [ -n \"$d\" ] && du -sh \"$d\" 2>/dev/null | cut -f1 || echo \"no la encuentro\"",
|
||||||
|
"Ocupa {ultima}."),
|
||||||
|
("proceso_buscar", "esta corriendo|se esta ejecutando|hay algun proceso de",
|
||||||
|
"Lo compruebo.", "pgrep -c -f {argumento} 2>/dev/null || echo 0",
|
||||||
|
"Hay {ultima} procesos que encajan."),
|
||||||
|
("proceso_matar", "mata el proceso|cierra el proceso|termina el proceso",
|
||||||
|
"Antes de matarlo, confirmeme.", "pkill -f {argumento}",
|
||||||
|
"Proceso terminado.", True),
|
||||||
|
("instalado", "tengo instalado|esta instalado",
|
||||||
|
"Lo miro.", "command -v {argumento} >/dev/null && echo si || echo no",
|
||||||
|
"Instalado: {ultima}."),
|
||||||
|
("manual", "para que sirve el comando|que hace el comando",
|
||||||
|
"Voy.", "whatis {argumento} 2>/dev/null | head -1", "{salida}"),
|
||||||
|
]
|
||||||
|
|
||||||
|
# --------------------------------------------------------------- oasis
|
||||||
|
# --------------------------------------------------------------- pentesting
|
||||||
|
# Red de seguridad: los escaneos ACTIVOS (que mandan paquetes a otros) llevan
|
||||||
|
# confirmar=True, asi que el dialogo muestra el comando exacto antes de lanzarse
|
||||||
|
# y la voz no puede disparar un escaneo sola. Los que apuntan a un objetivo se
|
||||||
|
# limitan a la RED LOCAL por construccion (autodetectan la subred o exigen IP
|
||||||
|
# privada); un objetivo de fuera se rechaza. Lo de solo lectura —buscar un
|
||||||
|
# exploit en la base local, resolver un dominio— va directo, no toca a nadie.
|
||||||
|
#
|
||||||
|
# Que apunte solo a la red local es a proposito: un asistente por voz que
|
||||||
|
# escanea lo que crea haber entendido, con salida al host, es un incidente
|
||||||
|
# esperando. Para objetivos de fuera, mejor a mano y con intencion.
|
||||||
|
PENTEST = [
|
||||||
|
("red_dispositivos", "escanea mi red|que hay en mi red|dispositivos en la red|quien esta en la red",
|
||||||
|
"Voy a escanear la red local, necesito su permiso.",
|
||||||
|
"R=$(ip route | awk '/proto.*src/{for(i=1;i<=NF;i++)if($i~/\\//)print $i; exit}'); "
|
||||||
|
"sudo nmap -sn ${R:-192.168.1.0/24} | grep -E 'Nmap scan|MAC' | head -30",
|
||||||
|
"Estos equipos hay en la red, señor: {salida}", True),
|
||||||
|
("puertos_host", "que puertos tiene abiertos|escanea los puertos de|escanea el host",
|
||||||
|
"Un escaneo de puertos, con su permiso.",
|
||||||
|
"T={argumento}; echo \"$T\" | grep -qE '^(10\\.|172\\.(1[6-9]|2[0-9]|3[01])\\.|192\\.168\\.|127\\.|localhost)' "
|
||||||
|
"&& nmap -F \"$T\" | grep -E '^[0-9]+/|Nmap scan' | head -20 "
|
||||||
|
"|| echo 'Solo objetivos de la red local, señor.'",
|
||||||
|
"{salida}", True),
|
||||||
|
("mis_puertos", "que puertos tengo abiertos yo|mis puertos abiertos|que estoy exponiendo",
|
||||||
|
"Lo compruebo.",
|
||||||
|
"ss -ltnp 2>/dev/null | awk 'NR>1{print $4}' | sort -u | head -15",
|
||||||
|
"Tengo {lineas} puertos a la escucha"),
|
||||||
|
("exploit_buscar", "busca un exploit para|busca exploits de|hay algun exploit de",
|
||||||
|
"Lo busco en la base de exploits.",
|
||||||
|
"searchsploit {argumento} 2>/dev/null | grep -vE '^-|Shellcode' | head -12",
|
||||||
|
"Esto he encontrado, señor: {salida}"),
|
||||||
|
("dominio_resolver", "resuelve el dominio|que ip tiene el dominio|a que ip apunta",
|
||||||
|
"Lo resuelvo.", "dig +short {argumento} 2>/dev/null | head -5",
|
||||||
|
"Resuelve a: {salida}"),
|
||||||
|
("dominio_whois", "de quien es el dominio|quien registro|whois de",
|
||||||
|
"Lo consulto.", "whois {argumento} 2>/dev/null | grep -iE 'registrar:|creation|expir|org' | head -6",
|
||||||
|
"{salida}"),
|
||||||
|
("cabeceras_web", "que servidor usa|cabeceras de|que tecnologia usa la web",
|
||||||
|
"Miro las cabeceras.",
|
||||||
|
"curl -sI --max-time 8 {argumento_url} 2>/dev/null | grep -iE 'server:|x-powered|location' | head -6",
|
||||||
|
"{salida}"),
|
||||||
|
("hash_identificar", "que tipo de hash es|identifica el hash",
|
||||||
|
"Lo miro.",
|
||||||
|
"H={argumento}; L=${#H}; case $L in 32)echo 'MD5, probablemente';; 40)echo 'SHA1';; "
|
||||||
|
"64)echo 'SHA256';; *)echo \"$L caracteres, no lo tengo claro\";; esac",
|
||||||
|
"{ultima}, señor."),
|
||||||
|
]
|
||||||
|
|
||||||
|
# las con argumento del bloque PENTEST (para marcar captura=True)
|
||||||
|
PENTEST_CAPTURA = {"puertos_host", "exploit_buscar", "dominio_resolver",
|
||||||
|
"dominio_whois", "cabeceras_web", "hash_identificar"}
|
||||||
|
|
||||||
|
OASIS = [
|
||||||
|
("oasis_corriendo", "esta oasis funcionando|esta corriendo oasis|oasis esta levantado",
|
||||||
|
"Lo compruebo.",
|
||||||
|
"pgrep -c -f 'oasis|ssb-server|sbot' 2>/dev/null || echo 0",
|
||||||
|
"Procesos de Oasis en marcha: {ultima}."),
|
||||||
|
("oasis_sincronizando", "estan sincronizando los pubs|como van los pubs|se estan sincronizando los pubs",
|
||||||
|
"Voy a mirar las conexiones.",
|
||||||
|
"python3 -c \"import json,time; d=json.load(open('$HOME/.ssb/conn.json')); "
|
||||||
|
"act=sum(1 for v in d.values() if time.time()*1000-v.get('stateChange',0)<300000); "
|
||||||
|
"fail=sum(1 for v in d.values() if v.get('failure',0)>0); "
|
||||||
|
"print(f'{len(d)} pubs, {act} activos hace poco, {fail} con fallos')\"",
|
||||||
|
"{ultima}."),
|
||||||
|
("oasis_conexiones", "cuantos pubs hay conectados|conexiones de oasis",
|
||||||
|
"Un momento.",
|
||||||
|
"cat ~/.ssb/conn.json 2>/dev/null | grep -c 'connected' || echo 0",
|
||||||
|
"Pubs conectados: {ultima}."),
|
||||||
|
("oasis_tamano", "cuanto ocupa oasis|tamaño de la base de ssb",
|
||||||
|
"Lo calculo.", "du -sh ~/.ssb 2>/dev/null | cut -f1",
|
||||||
|
"La base de SSB ocupa {ultima}."),
|
||||||
|
("oasis_abrir", "abre oasis|abreme oasis",
|
||||||
|
"Enseguida se lo abro.",
|
||||||
|
"xdg-open http://localhost:3000 2>/dev/null && echo abierto || echo 'no responde'",
|
||||||
|
"Oasis: {ultima}."),
|
||||||
|
("oasis_blobs", "cuanto ocupan los blobs|tamaño de los blobs",
|
||||||
|
"Voy.", "du -sh ~/.ssb/blobs 2>/dev/null | cut -f1", "Los blobs ocupan {ultima}."),
|
||||||
|
]
|
||||||
|
|
||||||
|
|
||||||
|
# Alias foneticos: lo que Whisper devuelve DE VERDAD, no lo que uno escribe.
|
||||||
|
# Medido con ocho ordenes habladas: "abre el correo" se transcribe "a ver el
|
||||||
|
# correo" (en castellano suenan igual), "los pubs" sale "los push" o "los
|
||||||
|
# puos", y "youtube" se parte en "yo tube". Añadirlos sube los aciertos sin
|
||||||
|
# tocar el modelo ni añadir un milisegundo.
|
||||||
|
ALIAS = {
|
||||||
|
"ff_gmail": ["a ver el correo", "abrir el correo"],
|
||||||
|
"oasis_sincronizando": ["estan sincronizando los push", "estan sincronizando los puos",
|
||||||
|
"sincronizando los pubs", "como van los push"],
|
||||||
|
"oasis_corriendo": ["esta oasis funcionando", "esta corriendo casis"],
|
||||||
|
"ff_buscar_youtube": ["busca en yo tube", "buscan youtube", "buscan yo tube",
|
||||||
|
"busca en you tube"],
|
||||||
|
"disco_libre": ["cuando espacio queda", "cuanto espacio quedan"],
|
||||||
|
"ff_youtube": ["abre yo tube", "abre you tube"],
|
||||||
|
"descargas_abrir": ["abre descargas", "abreme las descargas"],
|
||||||
|
"procesos_top": ["que esta consumiendo mas", "quien consume"],
|
||||||
|
"temperatura": ["que temperatura tiene", "como esta la temperatura"],
|
||||||
|
"bateria": ["cuanta bateria tengo", "como va la bateria"],
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
def con_señor(texto: str) -> str:
|
||||||
|
"""Mete el trato en las frases fijas.
|
||||||
|
|
||||||
|
Son las que mas suenan —el acuse va en cada orden— y hasta ahora eran las
|
||||||
|
unicas que no trataban de señor, asi que el personaje se caia justo ahi.
|
||||||
|
"""
|
||||||
|
if not texto or "señor" in texto.lower():
|
||||||
|
return texto
|
||||||
|
if texto.endswith("."):
|
||||||
|
return texto[:-1] + ", señor."
|
||||||
|
if texto.endswith("?"):
|
||||||
|
return texto[:-1] + ", señor?"
|
||||||
|
return texto + ", señor"
|
||||||
|
|
||||||
|
|
||||||
|
# Abrir una terminal y poner un video: de lo primero que se le pide a un
|
||||||
|
# asistente de escritorio, y no estaban. Las busquedas van acotadas y con
|
||||||
|
# tope porque el home son casi mil gigas y un find sin limite no vuelve.
|
||||||
|
ESCRITORIO = [
|
||||||
|
("terminal_abrir", "abre una terminal|abreme una terminal|abre la terminal|saca una terminal|quiero una terminal",
|
||||||
|
"Ahora mismo.", "gnome-terminal 2>/dev/null || kgx 2>/dev/null || xterm 2>/dev/null &",
|
||||||
|
"Terminal abierta."),
|
||||||
|
("terminal_aqui", "abre una terminal en el cofre|terminal en el cofre",
|
||||||
|
"Enseguida.", "gnome-terminal --working-directory=$HOME/COFRE 2>/dev/null || kgx 2>/dev/null &",
|
||||||
|
"Ahi la tiene, en el cofre."),
|
||||||
|
("videos_listar", "que peliculas tengo|que videos tengo|lista mis videos",
|
||||||
|
"Un momento, lo miro.", "timeout 12 find $HOME/Videos $HOME/Downloads $HOME/Desktop -type f -regextype posix-extended -iregex '.*\\.(mp4|mkv|avi|webm|mov|m4v)$' 2>/dev/null | head -12",
|
||||||
|
"He encontrado {lineas}."),
|
||||||
|
]
|
||||||
|
|
||||||
|
# esta captura el nombre de la pelicula
|
||||||
|
ESCRITORIO_CAPTURA = [
|
||||||
|
("pelicula_abrir", "pon la pelicula|abre la pelicula|reproduce el video|pon el video|quiero ver",
|
||||||
|
"Enseguida se la pongo.", "v=$(timeout 12 find $HOME/Videos $HOME/Downloads $HOME/Desktop -type f -regextype posix-extended -iregex '.*{argumento}.*\\.(mp4|mkv|avi|webm|mov|m4v)$' 2>/dev/null | head -1); if [ -n \"$v\" ]; then xdg-open \"$v\" >/dev/null 2>&1 & echo \"Poniendo $(basename \"$v\")\"; else echo \"No encuentro ese video\"; fi",
|
||||||
|
"{ultima}"),
|
||||||
|
]
|
||||||
|
|
||||||
|
# Ventanas y pantallas. Toda la logica vive en config/ventanas.sh (un script del
|
||||||
|
# host): aqui solo estan las frases y la llamada.
|
||||||
|
#
|
||||||
|
# Las frases llevan TRES palabras o mas y evitan a proposito ser subcadena de
|
||||||
|
# las que ya existen con "pantalla" o "ventana" dentro —apagar_pantalla,
|
||||||
|
# bloquear, captura_pantalla, ff_firefox_privado, ff_firefox_cerrar,
|
||||||
|
# proceso_matar, terminal_abrir—, porque el emparejador gana por frase mas
|
||||||
|
# larga sin mirar el grupo y una frase mal elegida se las come.
|
||||||
|
VENTANAS = [
|
||||||
|
("ventanas_listar", "que ventanas tengo abiertas|que ventanas hay abiertas|lista las ventanas",
|
||||||
|
"Un momento, lo miro.", "$HOME/COFRE/CODERS/JARVIS/config/ventanas.sh listar",
|
||||||
|
"Tiene {lineas} ventanas abiertas."),
|
||||||
|
|
||||||
|
("ventana_izquierda", "pon la ventana a la izquierda|manda la ventana a la izquierda|esta ventana a la izquierda",
|
||||||
|
"Ahora mismo.", "$HOME/COFRE/CODERS/JARVIS/config/ventanas.sh zona esta izquierda", "{ultima}"),
|
||||||
|
|
||||||
|
("ventana_derecha", "pon la ventana a la derecha|manda la ventana a la derecha|esta ventana a la derecha",
|
||||||
|
"Ahora mismo.", "$HOME/COFRE/CODERS/JARVIS/config/ventanas.sh zona esta derecha", "{ultima}"),
|
||||||
|
|
||||||
|
("ventana_arriba", "pon la ventana arriba del todo|manda la ventana arriba",
|
||||||
|
"Voy.", "$HOME/COFRE/CODERS/JARVIS/config/ventanas.sh zona esta arriba", "{ultima}"),
|
||||||
|
|
||||||
|
("ventana_abajo", "pon la ventana abajo del todo|manda la ventana abajo",
|
||||||
|
"Voy.", "$HOME/COFRE/CODERS/JARVIS/config/ventanas.sh zona esta abajo", "{ultima}"),
|
||||||
|
|
||||||
|
("ventana_centrar", "centra la ventana activa|pon la ventana en el centro",
|
||||||
|
"Enseguida.", "$HOME/COFRE/CODERS/JARVIS/config/ventanas.sh zona esta centro", "{ultima}"),
|
||||||
|
|
||||||
|
("ventana_maximizar", "maximiza la ventana activa|pon la ventana a pantalla completa",
|
||||||
|
"Ahora mismo.", "$HOME/COFRE/CODERS/JARVIS/config/ventanas.sh maximiza esta", "{ultima}"),
|
||||||
|
|
||||||
|
("ventana_restaurar", "restaura la ventana activa|quita la pantalla completa",
|
||||||
|
"Voy.", "$HOME/COFRE/CODERS/JARVIS/config/ventanas.sh restaura esta", "{ultima}"),
|
||||||
|
|
||||||
|
("ventana_minimizar", "minimiza la ventana activa|esconde la ventana activa",
|
||||||
|
"Voy.", "$HOME/COFRE/CODERS/JARVIS/config/ventanas.sh minimiza esta", "{ultima}"),
|
||||||
|
]
|
||||||
|
|
||||||
|
# Estas capturan lo que se dice detras: el nombre de la pantalla, el numero de
|
||||||
|
# escritorio o el mote que se le quiera poner a un monitor.
|
||||||
|
VENTANAS_CAPTURA = [
|
||||||
|
("ventana_a_pantalla", "manda la ventana a la pantalla|pasa la ventana a la pantalla",
|
||||||
|
"Ahora mismo.", "$HOME/COFRE/CODERS/JARVIS/config/ventanas.sh mover esta {argumento}", "{ultima}"),
|
||||||
|
|
||||||
|
("ventana_al_escritorio", "manda la ventana al escritorio|pasa la ventana al escritorio",
|
||||||
|
"Voy.", "$HOME/COFRE/CODERS/JARVIS/config/ventanas.sh escritorio esta {argumento}", "{ultima}"),
|
||||||
|
|
||||||
|
("pantalla_nombrar", "a esta pantalla llamala|llama a esta pantalla",
|
||||||
|
"Anotado.", "$HOME/COFRE/CODERS/JARVIS/config/ventanas.sh alias 1 {argumento}", "{ultima}"),
|
||||||
|
]
|
||||||
|
|
||||||
|
|
||||||
|
def fila(t, grupo, captura=False):
|
||||||
|
ident, frases, acuse, comando, respuesta = t[:5]
|
||||||
|
confirmar = len(t) > 5 and t[5]
|
||||||
|
return {
|
||||||
|
"id": ident,
|
||||||
|
"grupo": grupo,
|
||||||
|
"frases": frases.split("|"),
|
||||||
|
"acuse": con_señor(acuse or "Voy."),
|
||||||
|
"comando": comando,
|
||||||
|
"host": True,
|
||||||
|
"respuesta": con_señor(respuesta),
|
||||||
|
"confirmar": bool(confirmar),
|
||||||
|
"captura": captura,
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
def main():
|
||||||
|
acciones = [fila(t, "sistema") for t in SISTEMA]
|
||||||
|
acciones += [fila(t, "sistema") for t in ESCRITORIO]
|
||||||
|
acciones += [fila(t, "sistema", captura=True) for t in ESCRITORIO_CAPTURA]
|
||||||
|
acciones += [fila(t, "ventanas") for t in VENTANAS]
|
||||||
|
acciones += [fila(t, "ventanas", captura=True) for t in VENTANAS_CAPTURA]
|
||||||
|
acciones += [fila(t, "ficheros", captura=True) for t in CAPTURA]
|
||||||
|
acciones += [fila(t, "oasis") for t in OASIS]
|
||||||
|
acciones += [fila(t, "pentest", captura=t[0] in PENTEST_CAPTURA) for t in PENTEST]
|
||||||
|
|
||||||
|
# las de firefox viven en su propio fichero, que son otras cincuenta
|
||||||
|
firefox = pathlib.Path(__file__).parent / "_firefox.py"
|
||||||
|
if firefox.exists():
|
||||||
|
import importlib.util
|
||||||
|
spec = importlib.util.spec_from_file_location("firefox", firefox)
|
||||||
|
mod = importlib.util.module_from_spec(spec)
|
||||||
|
spec.loader.exec_module(mod)
|
||||||
|
acciones += mod.acciones()
|
||||||
|
|
||||||
|
# Los alias se aplican aqui, sobre la lista completa: si se hicieran al
|
||||||
|
# construir cada fila, las de firefox se quedarian fuera porque se generan
|
||||||
|
# en otro fichero. Se aprende por las malas.
|
||||||
|
for accion in acciones:
|
||||||
|
extra = ALIAS.get(accion["id"])
|
||||||
|
if extra:
|
||||||
|
accion["frases"] += [f for f in extra if f not in accion["frases"]]
|
||||||
|
|
||||||
|
salida = pathlib.Path(__file__).parent / "acciones.json"
|
||||||
|
salida.write_text(json.dumps({"version": 1, "acciones": acciones},
|
||||||
|
indent=2, ensure_ascii=False) + "\n")
|
||||||
|
|
||||||
|
ids = [a["id"] for a in acciones]
|
||||||
|
print(f"{len(acciones)} acciones escritas en {salida.name}")
|
||||||
|
if len(ids) != len(set(ids)):
|
||||||
|
repes = {i for i in ids if ids.count(i) > 1}
|
||||||
|
print(f"CUIDADO, ids repetidos: {repes}")
|
||||||
|
for grupo in sorted({a["grupo"] for a in acciones}):
|
||||||
|
print(f" {grupo:<10} {sum(1 for a in acciones if a['grupo'] == grupo)}")
|
||||||
|
|
||||||
|
|
||||||
|
if __name__ == "__main__":
|
||||||
|
main()
|
||||||
2179
nucleo/datos/acciones.json
Normal file
2179
nucleo/datos/acciones.json
Normal file
File diff suppressed because it is too large
Load diff
290
nucleo/estado.py
Executable file
290
nucleo/estado.py
Executable file
|
|
@ -0,0 +1,290 @@
|
||||||
|
#!/usr/bin/env python3
|
||||||
|
"""Por donde va la migracion, en la terminal.
|
||||||
|
|
||||||
|
./estado.py las barras
|
||||||
|
./estado.py -v y que falta exactamente en cada hito
|
||||||
|
./estado.py --rapido sin ejecutar nada, solo mirar ficheros
|
||||||
|
|
||||||
|
El porcentaje NO se escribe a mano: sale de comprobaciones de verdad —que un
|
||||||
|
fichero exista, que una funcion este, que una prueba pase—. Un contador que se
|
||||||
|
actualiza a mano miente a la semana, y ademas es justo lo que uno quiere que no
|
||||||
|
mienta: si dice 60 % es porque tres de cinco comprobaciones pasan ahora mismo.
|
||||||
|
|
||||||
|
Las que cuestan tiempo (arrancar whisper, hablar con ollama) van marcadas como
|
||||||
|
lentas y se saltan con --rapido.
|
||||||
|
"""
|
||||||
|
import argparse
|
||||||
|
import os
|
||||||
|
import subprocess
|
||||||
|
import sys
|
||||||
|
|
||||||
|
AQUI = os.path.dirname(os.path.abspath(__file__))
|
||||||
|
RAIZ = os.path.dirname(AQUI)
|
||||||
|
VENV = os.path.join(AQUI, "venv", "bin", "python")
|
||||||
|
|
||||||
|
|
||||||
|
# ------------------------------------------------------------- comprobantes
|
||||||
|
|
||||||
|
def hay(*trozos) -> bool:
|
||||||
|
return os.path.exists(os.path.join(AQUI, *trozos))
|
||||||
|
|
||||||
|
|
||||||
|
def dentro(fichero, texto) -> bool:
|
||||||
|
try:
|
||||||
|
with open(os.path.join(AQUI, fichero), encoding="utf-8") as f:
|
||||||
|
return texto in f.read()
|
||||||
|
except OSError:
|
||||||
|
return False
|
||||||
|
|
||||||
|
|
||||||
|
def corre(orden, espera=90) -> bool:
|
||||||
|
try:
|
||||||
|
r = subprocess.run(orden, cwd=AQUI, capture_output=True, timeout=espera)
|
||||||
|
return r.returncode == 0
|
||||||
|
except (OSError, subprocess.TimeoutExpired):
|
||||||
|
return False
|
||||||
|
|
||||||
|
|
||||||
|
def modulo(nombre) -> bool:
|
||||||
|
return corre([VENV if os.path.exists(VENV) else sys.executable,
|
||||||
|
"-c", f"import {nombre}"], espera=30)
|
||||||
|
|
||||||
|
|
||||||
|
def sin_comentarios(fichero, texto) -> bool:
|
||||||
|
"""Si el texto aparece en una linea que NO es un comentario."""
|
||||||
|
try:
|
||||||
|
with open(os.path.join(AQUI, fichero), encoding="utf-8") as f:
|
||||||
|
for l in f:
|
||||||
|
limpia = l.strip()
|
||||||
|
if limpia and not limpia.startswith(("#", "//", "*")) and texto in limpia:
|
||||||
|
return True
|
||||||
|
except OSError:
|
||||||
|
pass
|
||||||
|
return False
|
||||||
|
|
||||||
|
|
||||||
|
def catalogo_tiene(n) -> bool:
|
||||||
|
try:
|
||||||
|
import json
|
||||||
|
with open(os.path.join(AQUI, "datos", "acciones.json"), encoding="utf-8") as f:
|
||||||
|
return len(json.load(f)["acciones"]) >= n
|
||||||
|
except Exception:
|
||||||
|
return False
|
||||||
|
|
||||||
|
|
||||||
|
# ---------------------------------------------------------------- los hitos
|
||||||
|
#
|
||||||
|
# Cada comprobacion es (que se comprueba, como, si es lenta). El orden dentro
|
||||||
|
# de cada hito va de lo mas basico a lo mas fino, que es como se construyo.
|
||||||
|
|
||||||
|
HITOS = [
|
||||||
|
("la boca", "hablar por los altavoces", [
|
||||||
|
("el modulo esta", lambda: hay("boca", "voz.py"), False),
|
||||||
|
("hay tres voces o mas", lambda: dentro("boca/voz.py", '"claude"'), False),
|
||||||
|
("cache de frases por sha1", lambda: dentro("boca/voz.py", "_clave"), False),
|
||||||
|
("sabe si esta sonando", lambda: dentro("boca/voz.py", "def hablando"), False),
|
||||||
|
("habla de verdad", lambda: corre(
|
||||||
|
[VENV, "jarvis.py", "--di", "prueba"], 60), True),
|
||||||
|
]),
|
||||||
|
|
||||||
|
("el oido", "escuchar y transcribir", [
|
||||||
|
("captura con pw-record", lambda: dentro("oido/captura.py", "pw-record"), False),
|
||||||
|
("detector de voz Silero", lambda: modulo("pysilero_vad"), False),
|
||||||
|
("cliente de whisper-server", lambda: hay("oido", "whisper.py"), False),
|
||||||
|
("filtro de alucinaciones", lambda: dentro("oido/whisper.py", "def es_ruido"), False),
|
||||||
|
("guarda contra el eco", lambda: dentro("oido/captura.py", "boca.hablando"), False),
|
||||||
|
("whisper arranca y transcribe", lambda: corre(
|
||||||
|
[VENV, "-c",
|
||||||
|
"import sys;sys.path.insert(0,'.');from oido.whisper import Oido;"
|
||||||
|
"o=Oido();import sys as s;s.exit(0 if o.arranca() else 1)"], 90), True),
|
||||||
|
]),
|
||||||
|
|
||||||
|
("las manos", "ejecutar las 150 acciones", [
|
||||||
|
("el emparejador copiado", lambda: hay("manos", "acciones.py"), False),
|
||||||
|
("las tareas en paralelo", lambda: hay("manos", "tareas.py"), False),
|
||||||
|
("el catalogo entero", lambda: catalogo_tiene(150), False),
|
||||||
|
("una sola puerta para ejecutar", lambda: dentro("manos/__init__.py", "class Manos"), False),
|
||||||
|
("compara tambien por sonido", lambda: hay("manos", "fonetica.py"), False),
|
||||||
|
("banco fijo para medir", lambda: hay("datos", "banco.json"), False),
|
||||||
|
("las pruebas en verde", lambda: corre(
|
||||||
|
[VENV, "pruebas/prueba_manos.py"], 120), True),
|
||||||
|
]),
|
||||||
|
|
||||||
|
("el cerebro", "pensar lo que el catalogo no cubre", [
|
||||||
|
("cliente de ollama", lambda: hay("cerebro", "ollama.py"), False),
|
||||||
|
("dos herramientas, no una", lambda: dentro("cerebro/ollama.py", "comando_de_shell"), False),
|
||||||
|
("no puede inventarse datos", lambda: dentro("cerebro/ollama.py", "REGLA QUE NO SE ROMPE"), False),
|
||||||
|
("tope de vueltas", lambda: dentro("cerebro/ollama.py", "VUELTAS"), False),
|
||||||
|
("cadena catalogo-primero", lambda: dentro("jarvis.py", "def atiende"), False),
|
||||||
|
("ollama contesta", lambda: corre(
|
||||||
|
["curl", "-sf", "-m", "10", "http://127.0.0.1:11434/api/tags"], 20), True),
|
||||||
|
]),
|
||||||
|
|
||||||
|
("la palabra", "que le llamen JARVIS", [
|
||||||
|
("el centinela existe", lambda: hay("oido", "despierta.py"), False),
|
||||||
|
("se llama JARVIS", lambda: dentro("oido/despierta.py", 'NOMBRE = "jarvis"'), False),
|
||||||
|
("aguanta como lo oye Whisper", lambda: dentro("oido/despierta.py", "PARECIDAS"), False),
|
||||||
|
("la orden va en la misma frase", lambda: dentro("oido/despierta.py",
|
||||||
|
"def parte_el_nombre"), False),
|
||||||
|
("conectado al bucle de voz", lambda: dentro("jarvis.py", "centinela.filtra"), False),
|
||||||
|
# El que de verdad importaba: sin el prompt del nombre, Whisper nunca
|
||||||
|
# escribe JARVIS y el centinela no despierta jamas.
|
||||||
|
("prompt del nombre para Whisper", lambda: dentro("oido/whisper.py",
|
||||||
|
"PROMPT_NOMBRE"), False),
|
||||||
|
("boton para dormirlo y despertarlo", lambda: dentro("cara/panel.py",
|
||||||
|
'dato == "sueno"'), False),
|
||||||
|
("prueba de voz de punta a punta", lambda: hay("pruebas", "prueba_voz.py"), False),
|
||||||
|
("y la palabra va APAGADA por defecto", lambda: dentro("jarvis.py",
|
||||||
|
"activo=a.palabra"), False),
|
||||||
|
]),
|
||||||
|
|
||||||
|
("la cara", "el panel", [
|
||||||
|
("el HUD copiado", lambda: hay("cara", "hud", "index.html"), False),
|
||||||
|
("servidor http y websocket", lambda: hay("cara", "servidor.py"), False),
|
||||||
|
# El WebSocket vive en puente.js, no en hud.js: hud.js no se toca a
|
||||||
|
# proposito y el puente suplanta window.webkit por debajo.
|
||||||
|
("puente por WebSocket", lambda: dentro("cara/hud/puente.js", "WebSocket"), False),
|
||||||
|
("y hud.js sigue sin tocarse", lambda: dentro("cara/hud/hud.js",
|
||||||
|
"messageHandlers"), False),
|
||||||
|
("el panel se conecta al nucleo", lambda: dentro("cara/servidor.py", "async"), False),
|
||||||
|
# Ojo con las comprobaciones flojas: esta buscaba la palabra "tarea" en
|
||||||
|
# servidor.py y pasaba porque salia en un COMENTARIO, con las tarjetas
|
||||||
|
# sin conectar. Una barra que miente es peor que no tener barra.
|
||||||
|
("tarjetas de tareas en marcha", lambda: dentro("cara/panel.py",
|
||||||
|
"GestorTareas"), False),
|
||||||
|
("la consola lleva la conversacion", lambda: dentro("cara/hud/hud.js",
|
||||||
|
"aConsolaDicho"), False),
|
||||||
|
]),
|
||||||
|
|
||||||
|
("el dialogo", "que pregunte en vez de recitar", [
|
||||||
|
("las preguntas salen del catalogo", lambda: hay("manos", "preguntar.py"), False),
|
||||||
|
("pulsar pregunta lo que falta", lambda: dentro("cara/panel.py", "_pregunta("), False),
|
||||||
|
("la respuesta hablada la recoge", lambda: dentro("jarvis.py", "panel.responde"), False),
|
||||||
|
("lo destructivo confirma", lambda: dentro("cara/panel.py", "accion.confirmar"), False),
|
||||||
|
("y el panel enseña que espera", lambda: dentro("cara/hud/hud.js", "preguntando"), False),
|
||||||
|
("la prueba pasa", lambda: corre([VENV, "pruebas/prueba_dialogo.py"], 120), True),
|
||||||
|
]),
|
||||||
|
|
||||||
|
("el candado", "que no obedezca a cualquiera", [
|
||||||
|
("el candado en el HUD", lambda: dentro("cara/hud/index.html", "candado"), False),
|
||||||
|
("lo atiende el nucleo", lambda: dentro("cara/panel.py", "_intenta_desbloquear"), False),
|
||||||
|
("valida con la contrasena del sistema", lambda: dentro("cara/panel.py",
|
||||||
|
"GestorRoot"), False),
|
||||||
|
("con el candado puesto no ejecuta", lambda: dentro("cara/panel.py",
|
||||||
|
"no hay ordenes"), False),
|
||||||
|
("y la VOZ tampoco obedece", lambda: dentro("jarvis.py", "(bloqueado)"), False),
|
||||||
|
("la prueba pasa", lambda: corre([VENV, "pruebas/prueba_candado.py"], 120), True),
|
||||||
|
]),
|
||||||
|
|
||||||
|
("el saber", "conocer COFRE entero", [
|
||||||
|
("indexador de COFRE", lambda: hay("saber", "indexa.py"), False),
|
||||||
|
("busqueda por significado", lambda: hay("saber", "busca.py"), False),
|
||||||
|
("indice construido", lambda: hay("datos", "saber.jsonl"), False),
|
||||||
|
("el cerebro lo consulta antes de responder", lambda: dentro(
|
||||||
|
"cerebro/ollama.py", "def _saber"), False),
|
||||||
|
("filtra el codigo de terceros", lambda: dentro("saber/indexa.py", "IGNORA"), False),
|
||||||
|
("indexa la documentacion de Linux", lambda: hay("saber", "sistema.py"), False),
|
||||||
|
("y los servidores SSH", lambda: dentro("saber/sistema.py", "def servidores"), False),
|
||||||
|
("el cerebro puede ejecutar como root", lambda: dentro("manos/__init__.py",
|
||||||
|
"necesita_root"), False),
|
||||||
|
("root ligado al candado", lambda: dentro("cara/panel.py", "root.recuerda"), False),
|
||||||
|
]),
|
||||||
|
|
||||||
|
("el pipeline", "aprender del uso", [
|
||||||
|
("diario de lo que oye y hace", lambda: hay("manos", "diario.py"), False),
|
||||||
|
("apunta la VIA de cada frase", lambda: dentro("jarvis.py", 'anota(texto, "ruido")'), False),
|
||||||
|
("y tambien los aciertos", lambda: dentro("jarvis.py", '"catalogo", accion.id'), False),
|
||||||
|
("herramienta para revisarlo", lambda: hay("mejora.py"), False),
|
||||||
|
("propone, NO commitea solo", lambda: dentro("mejora.py", "Esto NO cambia nada"), False),
|
||||||
|
("mide contra el banco fijo", lambda: hay("datos", "banco.json"), False),
|
||||||
|
]),
|
||||||
|
|
||||||
|
("paridad", "usarlo a diario", [
|
||||||
|
("icono naranja", lambda: hay("jarvis-naranja.svg"), False),
|
||||||
|
("icono instalado", lambda: os.path.exists(os.path.expanduser(
|
||||||
|
"~/.local/share/icons/jarvis-nucleo.png")), False),
|
||||||
|
("lanzador propio", lambda: hay("arranca.sh"), False),
|
||||||
|
("ventana propia, no pestaña", lambda: hay("ventana.sh"), False),
|
||||||
|
# Se miran las lineas de CODIGO, no el fichero entero: el comentario que
|
||||||
|
# explica por que ya no se usa xdg-open contiene la palabra, y una
|
||||||
|
# comprobacion ingenua se cree que sigue ahi. Es la tercera vez que la
|
||||||
|
# barra casi miente por buscar texto suelto en vez de codigo.
|
||||||
|
("una sola forma de abrirla", lambda: not sin_comentarios(
|
||||||
|
"arranca.sh", "xdg-open"), False),
|
||||||
|
("la barra de tareas la reconoce", lambda: "StartupWMClass" in open(
|
||||||
|
os.path.expanduser("~/.local/share/applications/jarvis-nucleo.desktop")).read(), False),
|
||||||
|
("entrada en el escritorio", lambda: os.path.exists(os.path.expanduser(
|
||||||
|
"~/.local/share/applications/jarvis-nucleo.desktop")), False),
|
||||||
|
("Newelle congelado y aparte", lambda: corre(
|
||||||
|
["git", "-C", RAIZ, "rev-parse", "jarvis-newelle-final"], 15), False),
|
||||||
|
]),
|
||||||
|
]
|
||||||
|
|
||||||
|
|
||||||
|
# ------------------------------------------------------------------ pintarlo
|
||||||
|
|
||||||
|
ANCHO = 34
|
||||||
|
|
||||||
|
|
||||||
|
def color(t, c):
|
||||||
|
return f"\033[{c}m{t}\033[0m" if sys.stdout.isatty() else t
|
||||||
|
|
||||||
|
|
||||||
|
def barra(pct, hecho, total):
|
||||||
|
lleno = round(ANCHO * pct / 100)
|
||||||
|
# verde entero, amarillo a medias, gris sin empezar
|
||||||
|
c = "32" if pct == 100 else ("33" if pct > 0 else "90")
|
||||||
|
return color("█" * lleno, c) + color("·" * (ANCHO - lleno), "90")
|
||||||
|
|
||||||
|
|
||||||
|
def main() -> int:
|
||||||
|
p = argparse.ArgumentParser()
|
||||||
|
p.add_argument("-v", "--detalle", action="store_true")
|
||||||
|
p.add_argument("--rapido", action="store_true",
|
||||||
|
help="sin ejecutar nada, solo mirar ficheros")
|
||||||
|
a = p.parse_args()
|
||||||
|
|
||||||
|
if not os.path.exists(VENV):
|
||||||
|
print(color(" aviso: no hay venv; algunas comprobaciones no se pueden hacer\n", "33"))
|
||||||
|
|
||||||
|
print()
|
||||||
|
print(color(" JARVIS · migracion a nucleo propio", "1"))
|
||||||
|
print()
|
||||||
|
|
||||||
|
hechas = totales = 0
|
||||||
|
for i, (nombre, para_que, comprobaciones) in enumerate(HITOS, 1):
|
||||||
|
activas = [c for c in comprobaciones if not (a.rapido and c[2])]
|
||||||
|
pasan = []
|
||||||
|
for texto, prueba, lenta in activas:
|
||||||
|
try:
|
||||||
|
ok = bool(prueba())
|
||||||
|
except Exception:
|
||||||
|
ok = False
|
||||||
|
pasan.append((texto, ok, lenta))
|
||||||
|
n = sum(1 for _, ok, _ in pasan if ok)
|
||||||
|
pct = 100 * n / len(pasan) if pasan else 0
|
||||||
|
hechas += n
|
||||||
|
totales += len(pasan)
|
||||||
|
|
||||||
|
marca = color("✓", "32") if pct == 100 else (" " if pct == 0 else color("·", "33"))
|
||||||
|
print(f" {marca} {i}. {nombre:12s} {barra(pct, n, len(pasan))} "
|
||||||
|
f"{pct:3.0f}% {n}/{len(pasan)} {color(para_que, '90')}")
|
||||||
|
|
||||||
|
if a.detalle:
|
||||||
|
for texto, ok, lenta in pasan:
|
||||||
|
s = color(" ok ", "32") if ok else color(" --", "31")
|
||||||
|
print(f" {s} {texto}" + (color(" (lenta)", "90") if lenta else ""))
|
||||||
|
print()
|
||||||
|
|
||||||
|
print()
|
||||||
|
total_pct = 100 * hechas / totales if totales else 0
|
||||||
|
print(f" {'TOTAL':14s} {barra(total_pct, hechas, totales)} "
|
||||||
|
f"{total_pct:3.0f}% {hechas}/{totales}")
|
||||||
|
print()
|
||||||
|
if a.rapido:
|
||||||
|
print(color(" (rapido: sin las comprobaciones que ejecutan cosas)\n", "90"))
|
||||||
|
return 0
|
||||||
|
|
||||||
|
|
||||||
|
if __name__ == "__main__":
|
||||||
|
sys.exit(main())
|
||||||
55
nucleo/jarvis-naranja.svg
Normal file
55
nucleo/jarvis-naranja.svg
Normal file
|
|
@ -0,0 +1,55 @@
|
||||||
|
<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 256 256" width="256" height="256">
|
||||||
|
<!-- El mismo reactor que jarvis-icon.svg, en naranja.
|
||||||
|
La paleta no se inventa: es la del tema "ambar" del HUD (style.css),
|
||||||
|
para que el icono y la pantalla sean el mismo color.
|
||||||
|
|
||||||
|
Cian = JARVIS sobre Newelle, congelado.
|
||||||
|
Naranja = el nucleo independiente. Asi se sabe cual esta abierto. -->
|
||||||
|
<defs>
|
||||||
|
<radialGradient id="core" cx="50%" cy="50%" r="50%">
|
||||||
|
<stop offset="0%" stop-color="#fff0d8"/>
|
||||||
|
<stop offset="45%" stop-color="#ffb347"/>
|
||||||
|
<stop offset="100%" stop-color="#c8862a"/>
|
||||||
|
</radialGradient>
|
||||||
|
<radialGradient id="halo" cx="50%" cy="50%" r="50%">
|
||||||
|
<stop offset="0%" stop-color="#ffa040" stop-opacity=".55"/>
|
||||||
|
<stop offset="70%" stop-color="#c8862a" stop-opacity=".12"/>
|
||||||
|
<stop offset="100%" stop-color="#3a2810" stop-opacity="0"/>
|
||||||
|
</radialGradient>
|
||||||
|
<linearGradient id="ring" x1="0" y1="0" x2="0" y2="1">
|
||||||
|
<stop offset="0%" stop-color="#f5e3c7"/>
|
||||||
|
<stop offset="100%" stop-color="#92765a"/>
|
||||||
|
</linearGradient>
|
||||||
|
</defs>
|
||||||
|
|
||||||
|
<circle cx="128" cy="128" r="124" fill="#120c04"/>
|
||||||
|
<circle cx="128" cy="128" r="120" fill="url(#halo)"/>
|
||||||
|
|
||||||
|
<!-- carcasa exterior -->
|
||||||
|
<circle cx="128" cy="128" r="106" fill="none" stroke="url(#ring)" stroke-width="9"/>
|
||||||
|
<circle cx="128" cy="128" r="94" fill="none" stroke="#3f2a10" stroke-width="7"/>
|
||||||
|
|
||||||
|
<!-- bobinas -->
|
||||||
|
<g stroke="#efc78f" stroke-width="7" stroke-linecap="round" opacity=".9">
|
||||||
|
<line x1="128" y1="42" x2="128" y2="70"/>
|
||||||
|
<line x1="128" y1="186" x2="128" y2="214"/>
|
||||||
|
<line x1="42" y1="128" x2="70" y2="128"/>
|
||||||
|
<line x1="186" y1="128" x2="214" y2="128"/>
|
||||||
|
<line x1="67" y1="67" x2="87" y2="87"/>
|
||||||
|
<line x1="169" y1="169" x2="189" y2="189"/>
|
||||||
|
<line x1="189" y1="67" x2="169" y2="87"/>
|
||||||
|
<line x1="87" y1="169" x2="67" y2="189"/>
|
||||||
|
</g>
|
||||||
|
|
||||||
|
<!-- anillo interior -->
|
||||||
|
<circle cx="128" cy="128" r="70" fill="none" stroke="#7d541f" stroke-width="10"/>
|
||||||
|
<circle cx="128" cy="128" r="58" fill="none" stroke="#ffa040" stroke-width="4" opacity=".85"/>
|
||||||
|
|
||||||
|
<!-- triangulo del nucleo -->
|
||||||
|
<path d="M128 84 L166 150 L90 150 Z" fill="none" stroke="#ffe0b0" stroke-width="6"
|
||||||
|
stroke-linejoin="round" opacity=".95"/>
|
||||||
|
|
||||||
|
<!-- nucleo -->
|
||||||
|
<circle cx="128" cy="128" r="34" fill="url(#core)"/>
|
||||||
|
<circle cx="128" cy="128" r="16" fill="#ffffff" opacity=".92"/>
|
||||||
|
</svg>
|
||||||
|
After Width: | Height: | Size: 2.4 KiB |
330
nucleo/jarvis.py
Executable file
330
nucleo/jarvis.py
Executable file
|
|
@ -0,0 +1,330 @@
|
||||||
|
#!/usr/bin/env python3
|
||||||
|
"""JARVIS. Asistente de voz local, sin framework debajo.
|
||||||
|
|
||||||
|
jarvis.py --di "Buenas noches, señor" prueba la boca
|
||||||
|
jarvis.py --voces las que hay
|
||||||
|
jarvis.py --accion "cuanto espacio queda" prueba las manos, sin voz
|
||||||
|
|
||||||
|
Esto sustituye a la capa que corria dentro de Newelle. Lo que se trajo tal cual
|
||||||
|
—el emparejador, las tareas, el sudo, el HUD— esta en `manos/` y `cara/`; lo que
|
||||||
|
habia que reescribir porque era de Newelle esta en `oido/`, `boca/` y `cerebro/`.
|
||||||
|
|
||||||
|
## Por que fuera del flatpak
|
||||||
|
|
||||||
|
No es dogma, es que el sandbox costaba mas de lo que daba: escondia `/tmp`,
|
||||||
|
obligaba a `LD_LIBRARY_PATH` a mano para las libs de CUDA de whisper, metia un
|
||||||
|
`flatpak-spawn --host` en cada accion, y cambiar una linea de Python pedia
|
||||||
|
recompilar el paquete entero. Aqui un cambio es editar y reiniciar.
|
||||||
|
"""
|
||||||
|
import argparse
|
||||||
|
import os
|
||||||
|
import shutil
|
||||||
|
import subprocess
|
||||||
|
import sys
|
||||||
|
import time
|
||||||
|
|
||||||
|
AQUI = os.path.dirname(os.path.abspath(__file__))
|
||||||
|
sys.path.insert(0, AQUI)
|
||||||
|
|
||||||
|
from boca.voz import Boca, VOCES # noqa: E402
|
||||||
|
from cara.panel import Panel # noqa: E402
|
||||||
|
from cara.servidor import Cara # noqa: E402
|
||||||
|
from cerebro.ollama import Cerebro, MODELO # noqa: E402
|
||||||
|
from manos import Manos # noqa: E402
|
||||||
|
from manos.diario import anota # noqa: E402
|
||||||
|
from manos.acciones import Catalogo # noqa: E402
|
||||||
|
from oido.captura import Captura, fuentes # noqa: E402
|
||||||
|
from oido.despierta import Centinela, NOMBRE # noqa: E402
|
||||||
|
from oido.whisper import Oido, prompt_dominio, es_ruido # noqa: E402
|
||||||
|
|
||||||
|
CATALOGO = os.path.join(AQUI, "datos", "acciones.json")
|
||||||
|
PROPIO = os.path.expanduser("~/.config/jarvis/acciones.json")
|
||||||
|
|
||||||
|
|
||||||
|
def catalogo() -> Catalogo:
|
||||||
|
# El del usuario primero: puede redefinir cualquiera del paquete. Mismo
|
||||||
|
# orden que tenia el panel de Newelle.
|
||||||
|
return Catalogo([PROPIO, CATALOGO])
|
||||||
|
|
||||||
|
|
||||||
|
def atiende(texto, manos: Manos, cerebro: Cerebro | None, traza=print):
|
||||||
|
"""La cadena entera para una frase: catalogo primero, cerebro despues.
|
||||||
|
|
||||||
|
El orden no es un detalle de eficiencia, es lo que hace usable esto. Las 150
|
||||||
|
acciones se emparejan sin tocar ningun modelo y contestan al instante; el
|
||||||
|
cerebro solo ve lo que no encaja. Por eso un modelo lento se soporta: la
|
||||||
|
mayoria de las ordenes ni pasan por el.
|
||||||
|
"""
|
||||||
|
t0 = time.time()
|
||||||
|
accion, argumento = manos.busca(texto)
|
||||||
|
if accion is not None:
|
||||||
|
traza(f" catalogo: {accion.id}" + (f" <- {argumento}" if argumento else ""))
|
||||||
|
dicho, _ = manos.haz(accion, argumento)
|
||||||
|
anota(texto, "catalogo", accion.id, argumento, time.time() - t0, dicho)
|
||||||
|
return dicho
|
||||||
|
if cerebro is None:
|
||||||
|
traza(" (sin cerebro conectado)")
|
||||||
|
anota(texto, "sin-cerebro", seg=time.time() - t0)
|
||||||
|
return ""
|
||||||
|
traza(" al cerebro...")
|
||||||
|
dicho = cerebro.responde(texto, al_ejecutar=lambda i, a: traza(
|
||||||
|
f" usa {i}" + (f"({a[:52]})" if a else "")))
|
||||||
|
# La via mas valiosa del diario: lo que el catalogo NO cubre es justo la
|
||||||
|
# lista de acciones que faltan por escribir.
|
||||||
|
anota(texto, "cerebro", seg=time.time() - t0, dicho=dicho)
|
||||||
|
return dicho
|
||||||
|
|
||||||
|
|
||||||
|
def manda_accion(frase: str, boca: Boca | None = None, cerebro=None) -> int:
|
||||||
|
manos = Manos(catalogo())
|
||||||
|
dicho = atiende(frase, manos, cerebro, traza=lambda t: print(t))
|
||||||
|
if not dicho:
|
||||||
|
print(f' sin accion para "{frase}"')
|
||||||
|
return 1
|
||||||
|
print(f" {dicho}")
|
||||||
|
if boca:
|
||||||
|
boca.di(dicho)
|
||||||
|
return 0
|
||||||
|
|
||||||
|
|
||||||
|
def escucha(boca: Boca, modelo="small", fuente=None, callado=False,
|
||||||
|
cerebro=None, panel=None, centinela=None) -> int:
|
||||||
|
"""El bucle de verdad: oir, entender, hacer, contestar.
|
||||||
|
|
||||||
|
Es la version desnuda de lo que hacia el panel, sin GTK y sin HUD todavia.
|
||||||
|
Sirve para comprobar que la cadena entera funciona antes de ponerle cara.
|
||||||
|
"""
|
||||||
|
manos = Manos(catalogo())
|
||||||
|
# Con el prompt del NOMBRE, no con el del catalogo entero: sin el, Whisper
|
||||||
|
# nunca escribe "JARVIS" y el centinela no despierta jamas (ver whisper.py).
|
||||||
|
oreja = Oido(modelo=modelo)
|
||||||
|
if not oreja.disponible():
|
||||||
|
print(f" no encuentro whisper o el modelo {modelo}")
|
||||||
|
return 1
|
||||||
|
|
||||||
|
print(f" arrancando whisper ({modelo}, beam {oreja.beam}, sns, nombre)...")
|
||||||
|
if not oreja.arranca():
|
||||||
|
print(" whisper no arranco")
|
||||||
|
return 1
|
||||||
|
aviso = (f"esperando a que le llamen: «{NOMBRE.upper()}»"
|
||||||
|
if centinela and centinela.activo
|
||||||
|
else "atendiendo todo lo que oiga (--palabra para exigir el nombre)")
|
||||||
|
print(f" escuchando por {fuente or 'la entrada por defecto'}, {aviso}.")
|
||||||
|
print(" Ctrl+C para parar.\n")
|
||||||
|
if panel:
|
||||||
|
panel.estado("dormido" if centinela and centinela.activo else "escuchando")
|
||||||
|
|
||||||
|
# La captura consulta a la boca en cada trozo: mientras JARVIS habla, ese
|
||||||
|
# audio no se mira siquiera. Es lo que evita que se oiga a si mismo.
|
||||||
|
oreja_mic = Captura(boca=boca, fuente=fuente)
|
||||||
|
try:
|
||||||
|
for wav in oreja_mic.frases():
|
||||||
|
try:
|
||||||
|
texto = oreja.transcribe(wav)
|
||||||
|
finally:
|
||||||
|
try:
|
||||||
|
os.unlink(wav)
|
||||||
|
except OSError:
|
||||||
|
pass
|
||||||
|
|
||||||
|
if es_ruido(texto):
|
||||||
|
if texto:
|
||||||
|
print(f" · ruido descartado: {texto!r}")
|
||||||
|
anota(texto, "ruido")
|
||||||
|
if panel:
|
||||||
|
panel.dicho(texto, atendido=False, motivo="ruido")
|
||||||
|
continue
|
||||||
|
|
||||||
|
# ¿Hay una pregunta en el aire? Entonces esto es la respuesta.
|
||||||
|
#
|
||||||
|
# Va antes que TODO —antes de la palabra de activacion y antes del
|
||||||
|
# emparejador— porque si JARVIS acaba de preguntarte que fichero
|
||||||
|
# buscas, obligarte a decir "JARVIS, informes" seria absurdo: ya
|
||||||
|
# esta hablando contigo.
|
||||||
|
if panel and panel.esperando():
|
||||||
|
print(f" » {texto} (respondiendo a lo preguntado)")
|
||||||
|
anota(texto, "respuesta")
|
||||||
|
panel.dicho(texto)
|
||||||
|
if panel.responde(texto):
|
||||||
|
continue
|
||||||
|
|
||||||
|
# La palabra de activacion, antes de nada: sin esto obedece a
|
||||||
|
# cualquiera que pase, y a la tele.
|
||||||
|
if centinela:
|
||||||
|
atender, texto_orden, recien = centinela.filtra(texto)
|
||||||
|
if not atender:
|
||||||
|
if recien:
|
||||||
|
print(f" » {texto} (le han llamado)")
|
||||||
|
if panel:
|
||||||
|
panel.dicho(texto)
|
||||||
|
panel.estado("escuchando") # ya despierto
|
||||||
|
boca.di_si_libre("¿Señor?")
|
||||||
|
else:
|
||||||
|
print(f" · {texto} (no le han llamado)")
|
||||||
|
anota(texto, "sin-nombre")
|
||||||
|
# Se enseña IGUAL, marcado: que se vea que te ha oido
|
||||||
|
# bien y que lo unico que falta es llamarle.
|
||||||
|
if panel:
|
||||||
|
panel.dicho(texto, atendido=False,
|
||||||
|
motivo=f"diga «{NOMBRE.upper()}» primero")
|
||||||
|
continue
|
||||||
|
texto = texto_orden
|
||||||
|
|
||||||
|
# El candado tapa el panel, pero lo que hay que impedir es que
|
||||||
|
# OBEDEZCA: si no, quien pase por delante da ordenes hablando, que
|
||||||
|
# es justo lo que el candado existe para evitar.
|
||||||
|
if panel and getattr(panel, "candado", False) and not panel.desbloqueado:
|
||||||
|
print(f" · {texto} (bloqueado)")
|
||||||
|
anota(texto, "bloqueado")
|
||||||
|
panel.dicho(texto, atendido=False, motivo="hace falta la contraseña")
|
||||||
|
continue
|
||||||
|
|
||||||
|
print(f" » {texto}")
|
||||||
|
if panel:
|
||||||
|
panel.dicho(texto)
|
||||||
|
panel.estado("pensando")
|
||||||
|
dicho = atiende(texto, manos, cerebro)
|
||||||
|
if not dicho:
|
||||||
|
if panel:
|
||||||
|
panel.estado("escuchando")
|
||||||
|
continue
|
||||||
|
print(f" {dicho}")
|
||||||
|
if panel:
|
||||||
|
panel.respuesta(dicho)
|
||||||
|
panel.estado("hablando")
|
||||||
|
if not callado:
|
||||||
|
boca.di(dicho)
|
||||||
|
if panel:
|
||||||
|
# Sigue despierto un rato tras atender, para poder encadenar sin
|
||||||
|
# repetir el nombre: el rotulo tiene que decir eso y no "dormido".
|
||||||
|
panel.estado("escuchando" if not centinela or centinela.despierto
|
||||||
|
else "dormido")
|
||||||
|
except KeyboardInterrupt:
|
||||||
|
print("\n parado")
|
||||||
|
finally:
|
||||||
|
oreja_mic.para()
|
||||||
|
oreja.para()
|
||||||
|
return 0
|
||||||
|
|
||||||
|
|
||||||
|
def panel(boca: Boca, cerebro=None, escuchando=False, modelo="small",
|
||||||
|
fuente=None, abre=True, centinela=None, sin_candado=False) -> int:
|
||||||
|
"""Levanta el panel y, si se pide, ademas escucha el microfono."""
|
||||||
|
manos = Manos(catalogo())
|
||||||
|
cara = Cara()
|
||||||
|
p = Panel(cara, boca, manos, cerebro, candado=not sin_candado,
|
||||||
|
centinela=centinela)
|
||||||
|
cara.al_pulsar = p.pulsado
|
||||||
|
url = cara.arranca()
|
||||||
|
if not url:
|
||||||
|
return 1
|
||||||
|
p.arranca()
|
||||||
|
print(f" panel en {url}")
|
||||||
|
|
||||||
|
if abre:
|
||||||
|
# Una sola forma de abrir la ventana, en ventana.sh, para que sea igual
|
||||||
|
# se llegue por donde se llegue. Tener aqui su propia lista de
|
||||||
|
# navegadores fue lo que dejo que arranca.sh abriera una pestaña de
|
||||||
|
# Firefox cuando JARVIS ya estaba en marcha.
|
||||||
|
abridor = os.path.join(AQUI, "ventana.sh")
|
||||||
|
if os.access(abridor, os.X_OK):
|
||||||
|
subprocess.Popen([abridor, url], stdout=subprocess.DEVNULL,
|
||||||
|
stderr=subprocess.DEVNULL, start_new_session=True)
|
||||||
|
|
||||||
|
if not escuchando:
|
||||||
|
print(" sin microfono (--escucha para que ademas oiga). Ctrl+C para parar.")
|
||||||
|
try:
|
||||||
|
while True:
|
||||||
|
time.sleep(1)
|
||||||
|
except KeyboardInterrupt:
|
||||||
|
print("\n parado")
|
||||||
|
p.para()
|
||||||
|
return 0
|
||||||
|
|
||||||
|
return escucha(boca, modelo, fuente, False, cerebro, p, centinela)
|
||||||
|
|
||||||
|
|
||||||
|
def main() -> int:
|
||||||
|
p = argparse.ArgumentParser(description="JARVIS")
|
||||||
|
p.add_argument("--di", metavar="TEXTO", help="decir algo en voz alta")
|
||||||
|
p.add_argument("--voz", default=None, help="con que voz")
|
||||||
|
p.add_argument("--voces", action="store_true", help="listar las voces")
|
||||||
|
p.add_argument("--accion", metavar="FRASE", help="ejecutar una orden del catalogo")
|
||||||
|
p.add_argument("--callado", action="store_true", help="no hablar el resultado")
|
||||||
|
p.add_argument("--escucha", action="store_true", help="escuchar el microfono")
|
||||||
|
p.add_argument("--modelo", default="small", help="modelo de whisper")
|
||||||
|
p.add_argument("--fuente", default=None, help="entrada de audio (ver --fuentes)")
|
||||||
|
p.add_argument("--fuentes", action="store_true", help="listar las entradas")
|
||||||
|
p.add_argument("--cerebro", default=MODELO,
|
||||||
|
help="modelo de ollama; 'no' para trabajar solo con el catalogo")
|
||||||
|
p.add_argument("--ram", action="store_true",
|
||||||
|
help="el modelo entero en RAM, sin usar la grafica")
|
||||||
|
p.add_argument("--panel", action="store_true", help="abrir el panel")
|
||||||
|
p.add_argument("--sin-abrir", action="store_true",
|
||||||
|
help="levantar el panel pero no abrir el navegador")
|
||||||
|
p.add_argument("--palabra", action="store_true",
|
||||||
|
help=f"exigir que le llamen «{NOMBRE}» antes de cada orden")
|
||||||
|
p.add_argument("--sin-candado", action="store_true",
|
||||||
|
help="no pedir la contraseña al abrir (solo para probar)")
|
||||||
|
a = p.parse_args()
|
||||||
|
|
||||||
|
boca = Boca(a.voz or "davefx")
|
||||||
|
cerebro = None
|
||||||
|
if a.cerebro and a.cerebro != "no":
|
||||||
|
cerebro = Cerebro(catalogo(), modelo=a.cerebro, en_ram=a.ram,
|
||||||
|
manos=Manos(catalogo()))
|
||||||
|
|
||||||
|
if a.voces:
|
||||||
|
hay = boca.disponibles()
|
||||||
|
for nombre in VOCES:
|
||||||
|
marca = "·" if nombre in hay else "×"
|
||||||
|
actual = " <- puesta" if nombre == boca.voz else ""
|
||||||
|
print(f" {marca} {nombre}{actual}")
|
||||||
|
return 0
|
||||||
|
|
||||||
|
if a.di:
|
||||||
|
if a.voz and not boca.cambia(a.voz):
|
||||||
|
print(f" no existe la voz {a.voz}")
|
||||||
|
return 1
|
||||||
|
print(f" [{boca.voz}] {a.di}")
|
||||||
|
if not boca.di(a.di):
|
||||||
|
print(" no sono. mira que el modelo de la voz este en su sitio")
|
||||||
|
return 1
|
||||||
|
return 0
|
||||||
|
|
||||||
|
if a.fuentes:
|
||||||
|
for f in fuentes():
|
||||||
|
print(f" {f}")
|
||||||
|
return 0
|
||||||
|
|
||||||
|
# La palabra de activacion va APAGADA por defecto.
|
||||||
|
#
|
||||||
|
# Decirla en cada frase es un peaje, y medido no evitaba nada: sobre 412
|
||||||
|
# frases reales oidas —con todo el eco y el ruido ambiente dentro— solo 3
|
||||||
|
# habrian disparado una accion, y las tres eran ordenes de verdad. Cero
|
||||||
|
# falsos positivos del ruido, porque el emparejador ya es conservador.
|
||||||
|
#
|
||||||
|
# El candado cubre lo otro, que es quien puede darle ordenes.
|
||||||
|
#
|
||||||
|
# Se queda disponible con --palabra y en el boton del panel, por si algun
|
||||||
|
# dia hay una tele cerca y el ruido empieza a colarse.
|
||||||
|
centinela = Centinela(activo=a.palabra)
|
||||||
|
|
||||||
|
if a.panel:
|
||||||
|
return panel(boca, cerebro, a.escucha, a.modelo, a.fuente,
|
||||||
|
abre=not a.sin_abrir, centinela=centinela,
|
||||||
|
sin_candado=a.sin_candado)
|
||||||
|
|
||||||
|
if a.escucha:
|
||||||
|
return escucha(boca, a.modelo, a.fuente, a.callado, cerebro,
|
||||||
|
centinela=centinela)
|
||||||
|
|
||||||
|
if a.accion:
|
||||||
|
return manda_accion(a.accion, None if a.callado else boca, cerebro)
|
||||||
|
|
||||||
|
p.print_help()
|
||||||
|
return 0
|
||||||
|
|
||||||
|
|
||||||
|
if __name__ == "__main__":
|
||||||
|
sys.exit(main())
|
||||||
114
nucleo/manos/__init__.py
Normal file
114
nucleo/manos/__init__.py
Normal file
|
|
@ -0,0 +1,114 @@
|
||||||
|
"""Lo que JARVIS puede HACER, y el unico sitio por donde pasa.
|
||||||
|
|
||||||
|
`Manos` es la puerta: el catalogo entra por aqui, el cerebro entra por aqui y
|
||||||
|
el panel entrara por aqui. Tener un solo punto importa porque es donde se
|
||||||
|
decide que se ejecuta y que no, y esa decision no puede estar repartida.
|
||||||
|
|
||||||
|
Las cuatro piezas de debajo vienen tal cual de la version sobre Newelle
|
||||||
|
—`acciones.py`, `tareas.py`, `sudo_root.py`, `seleccion.py`— y se comprobo al
|
||||||
|
copiarlas que 374 frases dan exactamente el mismo resultado en los dos sitios.
|
||||||
|
"""
|
||||||
|
import os
|
||||||
|
import shlex
|
||||||
|
import subprocess
|
||||||
|
|
||||||
|
from .acciones import Catalogo, ejecuta, formatea
|
||||||
|
|
||||||
|
AQUI = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
|
||||||
|
CATALOGO = os.path.join(AQUI, "datos", "acciones.json")
|
||||||
|
PROPIO = os.path.expanduser("~/.config/jarvis/acciones.json")
|
||||||
|
|
||||||
|
# Lo que no se ejecuta por mucho que lo pida el modelo. No es una lista de
|
||||||
|
# seguridad completa —eso es imposible— sino un tope contra el accidente: el
|
||||||
|
# modelo es servicial y a veces se inventa una limpieza que nadie pidio.
|
||||||
|
PROHIBIDO = (
|
||||||
|
"rm -rf /", "mkfs", "dd if=", ":(){", "shutdown", "reboot", "halt",
|
||||||
|
"> /dev/sd", "chmod -R 777 /", "chown -R", "userdel", "passwd",
|
||||||
|
)
|
||||||
|
|
||||||
|
TOPE_SALIDA = 4000
|
||||||
|
|
||||||
|
|
||||||
|
class Manos:
|
||||||
|
def __init__(self, catalogo=None, al_ejecutar=None):
|
||||||
|
self.catalogo = catalogo or Catalogo([PROPIO, CATALOGO])
|
||||||
|
self.al_ejecutar = al_ejecutar
|
||||||
|
# Root para la sesion: cuando el usuario desbloquea el candado con su
|
||||||
|
# contraseña, esa misma queda aqui y el cerebro puede hacer sudo hasta
|
||||||
|
# que caduque. Sin desbloquear, no hay root: el candado es la puerta.
|
||||||
|
from manos.sudo_root import GestorRoot
|
||||||
|
self.root = GestorRoot([])
|
||||||
|
|
||||||
|
# ------------------------------------------------------------- catalogo
|
||||||
|
|
||||||
|
def busca(self, texto: str):
|
||||||
|
return self.catalogo.busca(texto)
|
||||||
|
|
||||||
|
def haz(self, accion, argumento="") -> tuple:
|
||||||
|
"""Ejecuta una accion ya emparejada. Devuelve (lo que se dice, crudo)."""
|
||||||
|
dicho, salida = ejecuta(accion, [], argumento)
|
||||||
|
if salida:
|
||||||
|
dicho = formatea(accion.respuesta, salida, argumento)
|
||||||
|
return dicho, salida
|
||||||
|
|
||||||
|
def por_orden(self, orden: str, al_ejecutar=None) -> str:
|
||||||
|
"""Para el cerebro: empareja contra el catalogo y ejecuta.
|
||||||
|
|
||||||
|
Devuelve texto para el modelo, no para el usuario: si no encaja, se le
|
||||||
|
dice claramente para que pruebe con el shell en vez de insistir.
|
||||||
|
"""
|
||||||
|
if not orden.strip():
|
||||||
|
return "no me has dicho ninguna orden"
|
||||||
|
# El modelo a veces cuela un comando aqui de todas formas. Se detecta y
|
||||||
|
# se le devuelve el motivo, que es mas util que un "no encontrado".
|
||||||
|
if any(c in orden for c in "|><;&$") or orden.split()[0] in ("df", "ls", "ps", "cat"):
|
||||||
|
return ("eso es un comando de shell, no una orden del catalogo. "
|
||||||
|
"Usa la herramienta comando_de_shell.")
|
||||||
|
accion, argumento = self.catalogo.busca(orden)
|
||||||
|
if accion is None:
|
||||||
|
return (f"'{orden}' no esta en el catalogo. Si hace falta, usa "
|
||||||
|
"comando_de_shell.")
|
||||||
|
if al_ejecutar or self.al_ejecutar:
|
||||||
|
(al_ejecutar or self.al_ejecutar)(accion.id, argumento)
|
||||||
|
dicho, salida = self.haz(accion, argumento)
|
||||||
|
return (salida or dicho)[:TOPE_SALIDA]
|
||||||
|
|
||||||
|
# ---------------------------------------------------------------- shell
|
||||||
|
|
||||||
|
def por_shell(self, comando: str, al_ejecutar=None) -> str:
|
||||||
|
if not comando.strip():
|
||||||
|
return "no me has dicho ningun comando"
|
||||||
|
bajo = comando.lower()
|
||||||
|
for veneno in PROHIBIDO:
|
||||||
|
if veneno in bajo:
|
||||||
|
return (f"no ejecuto eso: contiene '{veneno}'. Si de verdad hace "
|
||||||
|
"falta, que lo pida el usuario expresamente.")
|
||||||
|
if al_ejecutar or self.al_ejecutar:
|
||||||
|
(al_ejecutar or self.al_ejecutar)("shell", comando)
|
||||||
|
|
||||||
|
from manos.sudo_root import necesita_root
|
||||||
|
# Los comandos con sudo van por GestorRoot, que da la contraseña de la
|
||||||
|
# sesion por stdin. Sin ella, `bash -c "sudo ..."` se colgaria pidiendo
|
||||||
|
# una contraseña que nadie teclea. Y si el candado no se ha abierto, no
|
||||||
|
# hay contraseña: el root queda cerrado hasta que el usuario desbloquee.
|
||||||
|
if necesita_root(comando):
|
||||||
|
if not self.root.sesion_activa():
|
||||||
|
return ("eso necesita root y el candado no esta abierto. "
|
||||||
|
"Desbloquee con su contraseña y lo repito.")
|
||||||
|
try:
|
||||||
|
r = self.root.ejecuta(comando, timeout=60)
|
||||||
|
except Exception as e:
|
||||||
|
return f"no se pudo ejecutar como root: {e}"
|
||||||
|
else:
|
||||||
|
try:
|
||||||
|
r = subprocess.run(["bash", "-c", comando], capture_output=True,
|
||||||
|
text=True, timeout=60)
|
||||||
|
except subprocess.TimeoutExpired:
|
||||||
|
return "el comando tardo mas de un minuto y lo he cortado"
|
||||||
|
except OSError as e:
|
||||||
|
return f"no se pudo ejecutar: {e}"
|
||||||
|
|
||||||
|
salida = (r.stdout or r.stderr or "").strip()
|
||||||
|
if not salida:
|
||||||
|
return "hecho, sin salida" if r.returncode == 0 else f"fallo (codigo {r.returncode})"
|
||||||
|
return salida[:TOPE_SALIDA]
|
||||||
310
nucleo/manos/acciones.py
Normal file
310
nucleo/manos/acciones.py
Normal file
|
|
@ -0,0 +1,310 @@
|
||||||
|
"""Acciones rapidas: caminos predefinidos que se saltan el modelo.
|
||||||
|
|
||||||
|
Por que existe esto. Preguntar "cuanto espacio queda" y esperar a que un modelo
|
||||||
|
de 4B razone, decida llamar a una herramienta, la ejecute y redacte la
|
||||||
|
respuesta cuesta segundos. Pero esa pregunta no necesita pensarse: es un `df`.
|
||||||
|
El catalogo empareja la frase con un comando y contesta con una plantilla, y
|
||||||
|
eso baja de segundos a decimas.
|
||||||
|
|
||||||
|
No es entrenar un modelo: es una tabla. Y esa es la gracia, porque una tabla es
|
||||||
|
predecible, se lee, se corrige y no alucina. Lo que no encaje en la tabla sigue
|
||||||
|
yendo al modelo como siempre.
|
||||||
|
|
||||||
|
Formato del catalogo (JSON):
|
||||||
|
|
||||||
|
{
|
||||||
|
"acciones": [
|
||||||
|
{
|
||||||
|
"id": "disco_libre",
|
||||||
|
"frases": ["cuanto espacio queda", "espacio en disco"],
|
||||||
|
"acuse": "Un momento, lo miro.",
|
||||||
|
"comando": "df -h / | tail -1",
|
||||||
|
"host": true,
|
||||||
|
"respuesta": "Quedan {campo4} libres de {campo2}.",
|
||||||
|
"confirmar": false
|
||||||
|
}
|
||||||
|
]
|
||||||
|
}
|
||||||
|
|
||||||
|
En `respuesta` se puede usar:
|
||||||
|
{salida} la salida completa, recortada
|
||||||
|
{primera} la primera linea
|
||||||
|
{ultima} la ultima linea no vacia
|
||||||
|
{campoN} la columna N de la ultima linea (1 en adelante)
|
||||||
|
{lineas} cuantas lineas ha devuelto
|
||||||
|
"""
|
||||||
|
import difflib
|
||||||
|
import json
|
||||||
|
import os
|
||||||
|
import re
|
||||||
|
import shlex
|
||||||
|
import subprocess
|
||||||
|
import urllib.parse
|
||||||
|
import unicodedata
|
||||||
|
|
||||||
|
UMBRAL_PARECIDO = 0.86 # por debajo empieza a confundir ordenes
|
||||||
|
TIEMPO_LIMITE = 20 # ningun atajo deberia tardar mas
|
||||||
|
SALIDA_MAXIMA = 600 # lo que se guarda para enseñar y para la plantilla
|
||||||
|
|
||||||
|
|
||||||
|
def normaliza(texto: str) -> str:
|
||||||
|
"""Minusculas, sin tildes, sin puntuacion y con los espacios apretados.
|
||||||
|
|
||||||
|
Whisper devuelve "¿Cuánto espacio queda?" y el catalogo dice "cuanto
|
||||||
|
espacio queda". Sin normalizar no casaria ni una.
|
||||||
|
|
||||||
|
Lo de apretar los espacios no es cosmetico: al sustituir la puntuacion por
|
||||||
|
un espacio, "cuanto, espacio queda" quedaba con dos seguidos y dejaba de
|
||||||
|
coincidir con la frase del catalogo. El sintoma era un asistente que a
|
||||||
|
veces no reacciona a una orden que ha entendido bien, segun donde el
|
||||||
|
reconocedor decida poner una coma.
|
||||||
|
"""
|
||||||
|
texto = unicodedata.normalize("NFD", texto.lower())
|
||||||
|
texto = "".join(c for c in texto if unicodedata.category(c) != "Mn")
|
||||||
|
return " ".join(re.sub(r"[^\w\s]", " ", texto).split())
|
||||||
|
|
||||||
|
|
||||||
|
# El envoltorio de cortesia con el que habla cualquiera. Nadie dice "pon la
|
||||||
|
# pelicula" a secas: dice "necesito que pongas la pelicula" o "puedes ponerme".
|
||||||
|
# Con eso delante, ninguna frase del catalogo encaja como subcadena y la orden
|
||||||
|
# se pierde entera.
|
||||||
|
#
|
||||||
|
# Medido sobre las 462 frases que el panel anoto por no entender: de las 18 que
|
||||||
|
# eran ordenes de verdad, la mayoria fallaba solo por esto. Cinco de ellas eran
|
||||||
|
# el mismo intento de poner una pelicula, dicho de cinco maneras.
|
||||||
|
CORTESIA = re.compile(
|
||||||
|
r"^(por favor,?\s+)?"
|
||||||
|
r"(necesito que( me)?|quiero que( me)?|me gustaria que( me)?|"
|
||||||
|
r"puedes|podrias|me puedes|me podrias|te importa|hazme el favor de|"
|
||||||
|
r"a ver si|va(le|)?,? |anda,? |porfa,? |quiero|necesito)\s+",
|
||||||
|
re.I)
|
||||||
|
|
||||||
|
|
||||||
|
class Accion:
|
||||||
|
def __init__(self, datos: dict):
|
||||||
|
self.id = datos.get("id", "")
|
||||||
|
self.frases = [normaliza(f) for f in datos.get("frases", [])]
|
||||||
|
self.acuse = datos.get("acuse", "Voy.")
|
||||||
|
self.comando = datos.get("comando", "")
|
||||||
|
self.host = bool(datos.get("host", True))
|
||||||
|
self.respuesta = datos.get("respuesta", "{salida}")
|
||||||
|
self.confirmar = bool(datos.get("confirmar", False))
|
||||||
|
self.captura = bool(datos.get("captura", False))
|
||||||
|
self.grupo = datos.get("grupo", "")
|
||||||
|
|
||||||
|
def coincide(self, texto: str):
|
||||||
|
"""(longitud de la frase que encaja, lo que venia detras).
|
||||||
|
|
||||||
|
Se devuelve la longitud y no un si/no para poder quedarse con la
|
||||||
|
coincidencia mas especifica: "abre la carpeta de descargas" debe ganar
|
||||||
|
a "abre la carpeta" cuando las dos encajan.
|
||||||
|
|
||||||
|
El resto es el argumento: en "busca gatos en youtube" la frase es
|
||||||
|
"busca" ... y lo demas es lo que hay que buscar. Solo se recoge si la
|
||||||
|
accion lo pide, para que una frase suelta no arrastre basura.
|
||||||
|
"""
|
||||||
|
mejor, resto = 0, ""
|
||||||
|
for f in self.frases:
|
||||||
|
if not f or f not in texto:
|
||||||
|
continue
|
||||||
|
if len(f) > mejor:
|
||||||
|
mejor = len(f)
|
||||||
|
resto = texto.split(f, 1)[1].strip() if self.captura else ""
|
||||||
|
return mejor, resto
|
||||||
|
|
||||||
|
|
||||||
|
def parecido(a: str, b: str) -> float:
|
||||||
|
"""Cuanto se parecen dos cadenas, de 0 a 1, por letra y por sonido.
|
||||||
|
|
||||||
|
Para los casi-aciertos del reconocedor: "yo tuve" por "yo tube", "casis"
|
||||||
|
por "oasis". Se usa difflib y no una distancia de edicion propia porque
|
||||||
|
viene en la biblioteca estandar y aqui no hay que hilar tan fino.
|
||||||
|
|
||||||
|
Se queda con el MAYOR de los dos parecidos, el de la letra y el del sonido.
|
||||||
|
Muchos fallos del reconocedor no son de significado sino de ortografia
|
||||||
|
—"Abre van Kamp" por "abre bandcamp", "poops" por "pubs"— y por escrito
|
||||||
|
quedan lejos aunque suenen igual. Medido contra el banco: sube el acierto
|
||||||
|
de 79,3 a 84,7 % sin que ninguna de las 50 frases de charla dispare nada.
|
||||||
|
|
||||||
|
Que sea el maximo y no la media importa: la media hundiria los aciertos
|
||||||
|
normales, donde la letra ya casaba bien y el sonido no aporta.
|
||||||
|
"""
|
||||||
|
literal = difflib.SequenceMatcher(None, a, b).ratio()
|
||||||
|
if literal >= 0.98:
|
||||||
|
return literal # ya casa: no hace falta el sonido
|
||||||
|
from .fonetica import fonetica
|
||||||
|
return max(literal,
|
||||||
|
difflib.SequenceMatcher(None, fonetica(a), fonetica(b)).ratio())
|
||||||
|
|
||||||
|
|
||||||
|
class Catalogo:
|
||||||
|
def __init__(self, rutas):
|
||||||
|
self.acciones = []
|
||||||
|
self.errores = []
|
||||||
|
for ruta in rutas:
|
||||||
|
if ruta and os.path.exists(ruta):
|
||||||
|
self._carga(ruta)
|
||||||
|
|
||||||
|
def _carga(self, ruta):
|
||||||
|
try:
|
||||||
|
with open(ruta) as f:
|
||||||
|
datos = json.load(f)
|
||||||
|
except (OSError, json.JSONDecodeError) as e:
|
||||||
|
self.errores.append(f"{os.path.basename(ruta)}: {e}")
|
||||||
|
return
|
||||||
|
|
||||||
|
vistos = {a.id for a in self.acciones}
|
||||||
|
for entrada in datos.get("acciones", []):
|
||||||
|
accion = Accion(entrada)
|
||||||
|
if not accion.id or not accion.frases:
|
||||||
|
self.errores.append(f"{os.path.basename(ruta)}: accion sin id o sin frases")
|
||||||
|
continue
|
||||||
|
# el primero que se carga manda: asi el catalogo del usuario puede
|
||||||
|
# redefinir uno del paquete sin tener que borrarlo
|
||||||
|
if accion.id not in vistos:
|
||||||
|
self.acciones.append(accion)
|
||||||
|
vistos.add(accion.id)
|
||||||
|
|
||||||
|
def busca(self, texto: str):
|
||||||
|
"""(accion mas especifica que encaje, argumento) o (None, "").
|
||||||
|
|
||||||
|
Si no encaja nada, se reintenta quitando la cortesia de delante. Se
|
||||||
|
hace como SEGUNDA pasada y no normalizando desde el principio a
|
||||||
|
proposito: asi lo que ya funcionaba sigue funcionando igual, y esto
|
||||||
|
solo añade aciertos donde antes no habia ninguno.
|
||||||
|
"""
|
||||||
|
encontrada, argumento = self._busca_directa(normaliza(texto))
|
||||||
|
if encontrada is not None:
|
||||||
|
return encontrada, argumento
|
||||||
|
sin_cortesia = CORTESIA.sub("", normaliza(texto)).strip()
|
||||||
|
if sin_cortesia and sin_cortesia != normaliza(texto):
|
||||||
|
return self._busca_directa(sin_cortesia)
|
||||||
|
return None, ""
|
||||||
|
|
||||||
|
def _busca_directa(self, texto: str):
|
||||||
|
mejor, puntos, argumento = None, 0, ""
|
||||||
|
for accion in self.acciones:
|
||||||
|
p, resto = accion.coincide(texto)
|
||||||
|
if p > puntos:
|
||||||
|
mejor, puntos, argumento = accion, p, resto
|
||||||
|
|
||||||
|
# Nada exacto: se prueba por parecido. El reconocedor se come letras
|
||||||
|
# ("yo tuve" por "yo tube") y sin esto la orden se pierde entera. El
|
||||||
|
# umbral es alto a proposito: mas abajo empieza a confundir ordenes
|
||||||
|
# distintas entre si, que es peor que no reaccionar.
|
||||||
|
if mejor is None:
|
||||||
|
self._resto_parecido = ""
|
||||||
|
mejor, puntos = self._por_parecido(texto)
|
||||||
|
if mejor is not None and mejor.captura:
|
||||||
|
argumento = self._resto_parecido
|
||||||
|
|
||||||
|
# una accion que captura y no recibe nada no sirve: "busca" a secas
|
||||||
|
if mejor is not None and mejor.captura and not argumento:
|
||||||
|
return None, ""
|
||||||
|
return mejor, argumento
|
||||||
|
|
||||||
|
def _por_parecido(self, texto: str, umbral: float = UMBRAL_PARECIDO):
|
||||||
|
"""La accion cuya frase mas se parezca, si pasa del umbral."""
|
||||||
|
palabras = texto.split()
|
||||||
|
mejor, mejor_p = None, umbral
|
||||||
|
for accion in self.acciones:
|
||||||
|
if accion.captura:
|
||||||
|
# Con argumento no vale comparar la frase entera: "busca en
|
||||||
|
# youtube conciertos de techno" no se parece a "busca en
|
||||||
|
# youtube". Se compara solo el arranque y lo demas es el
|
||||||
|
# argumento. Se exigen tres palabras para que un disparador
|
||||||
|
# corto no se coma media conversacion.
|
||||||
|
for frase in accion.frases:
|
||||||
|
trozos = frase.split()
|
||||||
|
# Dos palabras, no tres. Con tres, disparadores cortos como
|
||||||
|
# "receta de" no entraban NUNCA en esta fase, y "receta de
|
||||||
|
# documentos" mal oido se perdia entero. El riesgo de bajar
|
||||||
|
# a dos lo cubre que la comparacion va anclada al principio:
|
||||||
|
# solo encaja si el arranque suena a la frase.
|
||||||
|
if len(trozos) < 2 or len(palabras) <= len(trozos):
|
||||||
|
continue
|
||||||
|
arranque = " ".join(palabras[:len(trozos)])
|
||||||
|
p = parecido(arranque, frase)
|
||||||
|
if p > mejor_p:
|
||||||
|
mejor, mejor_p = accion, p
|
||||||
|
self._resto_parecido = " ".join(palabras[len(trozos):])
|
||||||
|
continue
|
||||||
|
|
||||||
|
# Frase ENTERA contra frase entera, no por ventana deslizante. La
|
||||||
|
# ventana encontraba un sub-trozo que puntuaba alto aunque la orden
|
||||||
|
# fuera otra: "que carne el tiempo" (mal oido de "que kernel tengo")
|
||||||
|
# colaba en la accion del tiempo con 0.90, y se ejecutaba la accion
|
||||||
|
# equivocada —lo peor que puede pasar en algo que lanza comandos—.
|
||||||
|
# Una orden se dice completa; si va incrustada en una frase larga,
|
||||||
|
# el emparejador exacto (por subcadena) ya la coge antes de llegar
|
||||||
|
# aqui. Comparar el todo con el todo deja fuera esos falsos
|
||||||
|
# positivos sin perder los casi-aciertos reales.
|
||||||
|
propio = " ".join(palabras)
|
||||||
|
for frase in accion.frases:
|
||||||
|
if not frase:
|
||||||
|
continue
|
||||||
|
p = parecido(propio, frase)
|
||||||
|
if p > mejor_p:
|
||||||
|
mejor, mejor_p = accion, p
|
||||||
|
return mejor, mejor_p
|
||||||
|
|
||||||
|
def __len__(self):
|
||||||
|
return len(self.acciones)
|
||||||
|
|
||||||
|
|
||||||
|
def ejecuta(accion: Accion, prefijo_host, argumento: str = "") -> tuple:
|
||||||
|
"""Corre el comando y devuelve (texto para decir, salida cruda).
|
||||||
|
|
||||||
|
prefijo_host es lo que hay que anteponer para salir del sandbox; se pasa
|
||||||
|
como argumento en vez de importarlo para poder probar esto sin flatpak.
|
||||||
|
"""
|
||||||
|
if not accion.comando:
|
||||||
|
return accion.acuse, ""
|
||||||
|
|
||||||
|
# El argumento viene de un microfono, o sea de fuera: va entrecomillado con
|
||||||
|
# shlex antes de tocar un shell. Sin esto, decir "borra punto y coma rm"
|
||||||
|
# seria una orden ejecutable.
|
||||||
|
comando = accion.comando.replace("{argumento}", shlex.quote(argumento))
|
||||||
|
comando = comando.replace("{argumento_url}",
|
||||||
|
shlex.quote(urllib.parse.quote_plus(argumento)))
|
||||||
|
|
||||||
|
orden = ["bash", "-lc", comando]
|
||||||
|
if accion.host:
|
||||||
|
orden = list(prefijo_host) + orden
|
||||||
|
|
||||||
|
try:
|
||||||
|
# errors="replace": un grep o un cat que toque un binario devuelve
|
||||||
|
# bytes que no son utf-8, y sin esto la orden entera reventaria con
|
||||||
|
# UnicodeDecodeError. Mejor un caracter raro que un fallo.
|
||||||
|
r = subprocess.run(orden, capture_output=True, text=True,
|
||||||
|
errors="replace", timeout=TIEMPO_LIMITE)
|
||||||
|
salida = (r.stdout or r.stderr or "").strip()
|
||||||
|
except subprocess.TimeoutExpired:
|
||||||
|
return "La orden ha tardado demasiado y la he cancelado.", ""
|
||||||
|
except OSError as e:
|
||||||
|
return f"No he podido ejecutarlo: {e}", ""
|
||||||
|
|
||||||
|
return formatea(accion.respuesta, salida, argumento), salida[:SALIDA_MAXIMA]
|
||||||
|
|
||||||
|
|
||||||
|
def formatea(plantilla: str, salida: str, argumento: str = "") -> str:
|
||||||
|
lineas = [l for l in salida.splitlines() if l.strip()]
|
||||||
|
ultima = lineas[-1] if lineas else ""
|
||||||
|
campos = ultima.split()
|
||||||
|
|
||||||
|
valores = {
|
||||||
|
"argumento": argumento,
|
||||||
|
"salida": salida[:SALIDA_MAXIMA] if salida else "sin resultado",
|
||||||
|
"primera": lineas[0] if lineas else "",
|
||||||
|
"ultima": ultima,
|
||||||
|
"lineas": len(lineas),
|
||||||
|
}
|
||||||
|
for i, campo in enumerate(campos, start=1):
|
||||||
|
valores[f"campo{i}"] = campo
|
||||||
|
|
||||||
|
try:
|
||||||
|
return plantilla.format(**valores)
|
||||||
|
except (KeyError, IndexError, ValueError):
|
||||||
|
# plantilla que pide un campo que no existe: mejor decir la salida
|
||||||
|
# cruda que soltar una excepcion en mitad de una conversacion
|
||||||
|
return valores["salida"]
|
||||||
123
nucleo/manos/diario.py
Normal file
123
nucleo/manos/diario.py
Normal file
|
|
@ -0,0 +1,123 @@
|
||||||
|
"""Lo que JARVIS oye y que hace con ello. El combustible de todo lo demas.
|
||||||
|
|
||||||
|
Sin esto no hay forma de mejorar nada: no se puede arreglar lo que no se mide,
|
||||||
|
y hasta ahora el nucleo no apuntaba absolutamente nada.
|
||||||
|
|
||||||
|
## Por que este y no el de antes
|
||||||
|
|
||||||
|
El diario de la epoca de Newelle guardaba `{"texto": "..."}` y nada mas. Con eso
|
||||||
|
no se puede hacer casi nada:
|
||||||
|
|
||||||
|
- no se sabe **que paso** con la frase, asi que no se distingue una orden que
|
||||||
|
fallo de una que funciono;
|
||||||
|
- no se sabe **cuando**, asi que no se ve si alguien repitio la misma cosa de
|
||||||
|
tres formas seguidas —que es la señal mas valiosa que hay—;
|
||||||
|
- y solo guardaba los FALLOS, asi que no habia con que comparar.
|
||||||
|
|
||||||
|
Ademas se llenaba de eco y de alucinaciones de Whisper, y la mejora nocturna
|
||||||
|
acabo generando alias a partir del ruido. De 504 frases, 306 parecian ordenes
|
||||||
|
sin atender y al mirarlas casi todas eran JARVIS oyendose a si mismo.
|
||||||
|
|
||||||
|
## Que se guarda
|
||||||
|
|
||||||
|
Todo lo que llega, con su destino. Una linea por frase, JSON:
|
||||||
|
|
||||||
|
t cuando
|
||||||
|
oido lo que transcribio Whisper
|
||||||
|
via catalogo | cerebro | ruido | bloqueado | respuesta
|
||||||
|
accion a que accion fue, si fue a alguna
|
||||||
|
arg con que argumento
|
||||||
|
seg lo que tardo en contestar
|
||||||
|
dicho lo que contesto
|
||||||
|
|
||||||
|
Guardar TAMBIEN los aciertos es lo que permite comparar: sin ellos, un dia malo
|
||||||
|
y un dia bueno tienen el mismo aspecto.
|
||||||
|
|
||||||
|
## Lo que NO se guarda
|
||||||
|
|
||||||
|
Nada de audio. El diario es texto y se puede leer con `less`; si algun dia
|
||||||
|
guardara los WAV, el asistente pasaria a ser una grabadora de la habitacion y
|
||||||
|
eso es otra cosa muy distinta de lo que es.
|
||||||
|
"""
|
||||||
|
import json
|
||||||
|
import os
|
||||||
|
import threading
|
||||||
|
import time
|
||||||
|
from datetime import datetime
|
||||||
|
|
||||||
|
AQUI = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
|
||||||
|
DIARIO = os.path.join(AQUI, "datos", "diario.jsonl")
|
||||||
|
|
||||||
|
# Un diario que crece sin fin acaba siendo un problema en vez de una ayuda. A
|
||||||
|
# ~150 bytes por linea, 200.000 son unos 30 MB: mas que suficiente para meses de
|
||||||
|
# uso y poco para el disco.
|
||||||
|
TOPE_LINEAS = 200_000
|
||||||
|
|
||||||
|
_cerrojo = threading.Lock()
|
||||||
|
|
||||||
|
|
||||||
|
def anota(oido: str, via: str, accion: str = "", arg: str = "",
|
||||||
|
seg: float = 0.0, dicho: str = "", ruta: str = DIARIO):
|
||||||
|
"""Apunta una frase y su destino. No falla nunca hacia fuera.
|
||||||
|
|
||||||
|
Si escribir el diario diera error, lo ultimo que debe hacer es tirar al
|
||||||
|
asistente: se pierde una linea y ya.
|
||||||
|
"""
|
||||||
|
if not oido:
|
||||||
|
return
|
||||||
|
linea = {
|
||||||
|
"t": datetime.now().isoformat(timespec="seconds"),
|
||||||
|
"oido": oido[:400],
|
||||||
|
"via": via,
|
||||||
|
}
|
||||||
|
if accion:
|
||||||
|
linea["accion"] = accion
|
||||||
|
if arg:
|
||||||
|
linea["arg"] = arg[:200]
|
||||||
|
if seg:
|
||||||
|
linea["seg"] = round(seg, 2)
|
||||||
|
if dicho:
|
||||||
|
linea["dicho"] = dicho[:300]
|
||||||
|
|
||||||
|
try:
|
||||||
|
with _cerrojo:
|
||||||
|
os.makedirs(os.path.dirname(ruta), exist_ok=True)
|
||||||
|
with open(ruta, "a", encoding="utf-8") as f:
|
||||||
|
f.write(json.dumps(linea, ensure_ascii=False) + "\n")
|
||||||
|
except OSError:
|
||||||
|
pass
|
||||||
|
|
||||||
|
|
||||||
|
def lee(ruta: str = DIARIO, desde=None) -> list:
|
||||||
|
"""Las lineas del diario, ya en diccionarios. Salta las corruptas."""
|
||||||
|
salida = []
|
||||||
|
try:
|
||||||
|
with open(ruta, encoding="utf-8") as f:
|
||||||
|
for l in f:
|
||||||
|
try:
|
||||||
|
d = json.loads(l)
|
||||||
|
except json.JSONDecodeError:
|
||||||
|
continue
|
||||||
|
if desde and d.get("t", "") < desde:
|
||||||
|
continue
|
||||||
|
salida.append(d)
|
||||||
|
except OSError:
|
||||||
|
pass
|
||||||
|
return salida
|
||||||
|
|
||||||
|
|
||||||
|
def recorta(ruta: str = DIARIO, tope: int = TOPE_LINEAS):
|
||||||
|
"""Deja solo las ultimas `tope` lineas."""
|
||||||
|
lineas = []
|
||||||
|
try:
|
||||||
|
with open(ruta, encoding="utf-8") as f:
|
||||||
|
lineas = f.readlines()
|
||||||
|
except OSError:
|
||||||
|
return
|
||||||
|
if len(lineas) <= tope:
|
||||||
|
return
|
||||||
|
try:
|
||||||
|
with _cerrojo, open(ruta, "w", encoding="utf-8") as f:
|
||||||
|
f.writelines(lineas[-tope:])
|
||||||
|
except OSError:
|
||||||
|
pass
|
||||||
84
nucleo/manos/fonetica.py
Normal file
84
nucleo/manos/fonetica.py
Normal file
|
|
@ -0,0 +1,84 @@
|
||||||
|
"""Comparar por como SUENA, no por como se escribe.
|
||||||
|
|
||||||
|
## Que problema resuelve
|
||||||
|
|
||||||
|
Midiendo donde se pierde el acierto salio esto: de 150 ordenes dichas, el 79 %
|
||||||
|
llega a su accion, un 5 % se oye mal de verdad, y un **15 % se oye bien pero el
|
||||||
|
emparejador no lo relaciona**. Mirando esos casos uno a uno, no son ordenes
|
||||||
|
distintas: son la misma orden mal escrita.
|
||||||
|
|
||||||
|
dijo "receta de documentos" oyo "Leceta de documentos"
|
||||||
|
dijo "como van los pubs" oyo "¿Como van los poops?"
|
||||||
|
dijo "abre bandcamp" oyo "Abre van Kamp"
|
||||||
|
dijo "abre el drive" oyo "Abril Drive"
|
||||||
|
dijo "abreme oasis" oyo "Abre mi roasis"
|
||||||
|
|
||||||
|
Eso NO se arregla con embeddings: un modelo semantico ve "Leceta" como una
|
||||||
|
palabra inexistente, no como "receta". Y bajar el umbral de parecido tampoco,
|
||||||
|
porque el umbral esta alto por una razon —hay una cicatriz en el codigo de
|
||||||
|
cuando "que carne el tiempo" se colaba en la accion del tiempo y ejecutaba lo
|
||||||
|
que no era—.
|
||||||
|
|
||||||
|
Lo que sirve es comparar como suena. En castellano hay unas pocas confusiones
|
||||||
|
que lo explican casi todo, y son las que aplica `fonetica()`.
|
||||||
|
|
||||||
|
## Lo que NO hace
|
||||||
|
|
||||||
|
No es un Soundex ni un Metaphone: esos comprimen tanto que juntan palabras que
|
||||||
|
no se parecen, y aqui juntar de mas significa ejecutar la orden equivocada, que
|
||||||
|
es lo peor que puede hacer esto. Se queda en las equivalencias que de verdad
|
||||||
|
confunde el reconocedor de voz en castellano, y nada mas.
|
||||||
|
"""
|
||||||
|
import re
|
||||||
|
import unicodedata
|
||||||
|
|
||||||
|
# El orden importa: cada regla se aplica sobre el resultado de la anterior.
|
||||||
|
REGLAS = (
|
||||||
|
# la hache no suena
|
||||||
|
(r"h", ""),
|
||||||
|
# b y v son el mismo sonido: "van Kamp" / "bandcamp"
|
||||||
|
(r"v", "b"),
|
||||||
|
# ge/gi suenan como jota
|
||||||
|
(r"g([ei])", r"j\1"),
|
||||||
|
# gue/gui: la u es muda
|
||||||
|
(r"gu([ei])", r"g\1"),
|
||||||
|
# que/qui igual, y qu -> k
|
||||||
|
(r"qu([ei])", r"k\1"),
|
||||||
|
(r"q", "k"),
|
||||||
|
# ce/ci en seseo suenan como ese; ca/co/cu como ka
|
||||||
|
(r"c([ei])", r"s\1"),
|
||||||
|
(r"c", "k"),
|
||||||
|
# z siempre ese (seseo): asi "poops"/"pubs" y "haz"/"has" caen juntos
|
||||||
|
(r"z", "s"),
|
||||||
|
# x entre vocales suena ks, pero al principio suele ser ese
|
||||||
|
(r"^x", "s"),
|
||||||
|
(r"x", "ks"),
|
||||||
|
# ll e y son el mismo sonido para casi todo el mundo
|
||||||
|
(r"ll", "y"),
|
||||||
|
# w es de fuera: suena como u o como b segun la palabra; se unifica a b
|
||||||
|
(r"w", "b"),
|
||||||
|
# la erre doble y la simple no se distinguen al transcribir
|
||||||
|
(r"rr", "r"),
|
||||||
|
# la ñ se escribe de mil formas cuando el reconocedor duda
|
||||||
|
(r"ñ", "n"),
|
||||||
|
# las dobles no aportan: "poops" -> "pops"
|
||||||
|
(r"(.)\1+", r"\1"),
|
||||||
|
# las vocales finales se comen mucho; y la ese final tambien
|
||||||
|
(r"s$", ""),
|
||||||
|
)
|
||||||
|
|
||||||
|
|
||||||
|
def fonetica(texto: str) -> str:
|
||||||
|
"""Como suena, aproximadamente, para poder comparar dos oidos distintos."""
|
||||||
|
t = unicodedata.normalize("NFD", (texto or "").lower())
|
||||||
|
t = "".join(c for c in t if unicodedata.category(c) != "Mn" or c == "̃")
|
||||||
|
t = unicodedata.normalize("NFC", t)
|
||||||
|
t = re.sub(r"[^a-zñ\s]", " ", t)
|
||||||
|
|
||||||
|
palabras = []
|
||||||
|
for p in t.split():
|
||||||
|
for patron, cambio in REGLAS:
|
||||||
|
p = re.sub(patron, cambio, p)
|
||||||
|
if p:
|
||||||
|
palabras.append(p)
|
||||||
|
return " ".join(palabras)
|
||||||
115
nucleo/manos/medidas.py
Normal file
115
nucleo/manos/medidas.py
Normal file
|
|
@ -0,0 +1,115 @@
|
||||||
|
"""Las medidas de eficiencia de JARVIS, sacadas del diario.
|
||||||
|
|
||||||
|
El diario ya apunta por cada frase: cuanto tardo (`seg`), por donde fue (`via`)
|
||||||
|
y cuando (`t`). De ahi salen las metricas de rendimiento sin instrumentar nada
|
||||||
|
del camino caliente: esto solo LEE, y se calcula fuera del hilo que contesta.
|
||||||
|
|
||||||
|
## Que se mide y por que importa cada una
|
||||||
|
|
||||||
|
latencia p50/p95/max del tiempo de respuesta. La mediana dice como va de
|
||||||
|
normal; el p95 dice como va cuando va mal, que es lo que se nota.
|
||||||
|
reparto que fraccion va al CEREBRO (lento, ~2-3 s) y cual al CATALOGO
|
||||||
|
(instantaneo, salta el modelo). Es la palanca de eficiencia mas
|
||||||
|
grande: cuanto mas catalogo, mas rapido el conjunto.
|
||||||
|
ruido que fraccion de lo que oye es Whisper oyendose a si mismo. No es
|
||||||
|
velocidad, es calidad de la escucha, y envenena todo lo demas.
|
||||||
|
volumen frases en las ultimas 24 h. Contexto para lo anterior: un p95 malo
|
||||||
|
con 4 frases no dice nada.
|
||||||
|
rag hit@5/hit@1 del ultimo benchmark del RAG (informe_rag.txt). Es la
|
||||||
|
unica que no sale del diario: es una medida de test, periodica.
|
||||||
|
|
||||||
|
Todo sobre una VENTANA reciente (las ultimas MUESTRA frases), no sobre el diario
|
||||||
|
entero: interesa como va AHORA, no la media historica que nunca cambia.
|
||||||
|
"""
|
||||||
|
import os
|
||||||
|
import re
|
||||||
|
from datetime import datetime, timedelta
|
||||||
|
|
||||||
|
from manos.diario import lee
|
||||||
|
|
||||||
|
AQUI = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
|
||||||
|
INFORME_RAG = os.path.join(AQUI, "datos", "informe_rag.txt")
|
||||||
|
|
||||||
|
MUESTRA = 600 # las ultimas N frases: "como va ahora"
|
||||||
|
CEREBRO = "cerebro"
|
||||||
|
|
||||||
|
|
||||||
|
def _percentil(valores, q):
|
||||||
|
if not valores:
|
||||||
|
return 0.0
|
||||||
|
v = sorted(valores)
|
||||||
|
k = (len(v) - 1) * q
|
||||||
|
lo, hi = int(k), min(int(k) + 1, len(v) - 1)
|
||||||
|
return v[lo] + (v[hi] - v[lo]) * (k - lo)
|
||||||
|
|
||||||
|
|
||||||
|
def _rag():
|
||||||
|
"""hit@5 y hit@1 del ultimo informe del RAG, si existe."""
|
||||||
|
try:
|
||||||
|
txt = open(INFORME_RAG, encoding="utf-8").read()
|
||||||
|
except OSError:
|
||||||
|
return None
|
||||||
|
# el bloque CANDIDATO es el que se promociono; si no, el ultimo que haya
|
||||||
|
def pct(clave):
|
||||||
|
# " hit@5 43/45 (95%)" -> 95
|
||||||
|
ms = re.findall(clave + r"\s+\d+/\d+\s+\((\d+)%\)", txt)
|
||||||
|
return int(ms[-1]) if ms else None
|
||||||
|
h5, h1 = pct("hit@5"), pct("hit@1")
|
||||||
|
if h5 is None:
|
||||||
|
return None
|
||||||
|
return {"hit5": h5, "hit1": h1 or 0}
|
||||||
|
|
||||||
|
|
||||||
|
def lee_medidas():
|
||||||
|
"""El dict de medidas, con las unidades ya listas para el HUD."""
|
||||||
|
diario = lee()[-MUESTRA:]
|
||||||
|
if not diario:
|
||||||
|
return {"n": 0}
|
||||||
|
|
||||||
|
segs = [d["seg"] for d in diario if isinstance(d.get("seg"), (int, float)) and d["seg"] > 0]
|
||||||
|
seg_cerebro = [d["seg"] for d in diario
|
||||||
|
if d.get("via") == CEREBRO and isinstance(d.get("seg"), (int, float))]
|
||||||
|
seg_catalogo = [d["seg"] for d in diario
|
||||||
|
if d.get("via") == "catalogo" and isinstance(d.get("seg"), (int, float))]
|
||||||
|
|
||||||
|
vias = {}
|
||||||
|
for d in diario:
|
||||||
|
vias[d.get("via", "?")] = vias.get(d.get("via", "?"), 0) + 1
|
||||||
|
total = len(diario)
|
||||||
|
|
||||||
|
def pct_via(v):
|
||||||
|
return round(100 * vias.get(v, 0) / total) if total else 0
|
||||||
|
|
||||||
|
# volumen: cuantas en las ultimas 24 h, y por hora las ultimas 12 para la traza
|
||||||
|
ahora = datetime.now()
|
||||||
|
hace24 = ahora - timedelta(hours=24)
|
||||||
|
vol24 = 0
|
||||||
|
porhora = [0] * 12
|
||||||
|
for d in diario:
|
||||||
|
try:
|
||||||
|
t = datetime.fromisoformat(d.get("t", ""))
|
||||||
|
except (ValueError, TypeError):
|
||||||
|
continue
|
||||||
|
if t >= hace24:
|
||||||
|
vol24 += 1
|
||||||
|
h = int((ahora - t).total_seconds() // 3600)
|
||||||
|
if 0 <= h < 12:
|
||||||
|
porhora[11 - h] += 1
|
||||||
|
|
||||||
|
medidas = {
|
||||||
|
"n": total,
|
||||||
|
"lat_p50": round(_percentil(segs, 0.50), 2),
|
||||||
|
"lat_p95": round(_percentil(segs, 0.95), 2),
|
||||||
|
"lat_max": round(max(segs), 2) if segs else 0.0,
|
||||||
|
"lat_cerebro": round(sum(seg_cerebro) / len(seg_cerebro), 2) if seg_cerebro else 0.0,
|
||||||
|
"lat_catalogo": round(sum(seg_catalogo) / len(seg_catalogo), 2) if seg_catalogo else 0.0,
|
||||||
|
"pct_cerebro": pct_via("cerebro"),
|
||||||
|
"pct_catalogo": pct_via("catalogo"),
|
||||||
|
"pct_ruido": pct_via("ruido"),
|
||||||
|
"vol24": vol24,
|
||||||
|
"porhora": porhora,
|
||||||
|
}
|
||||||
|
rag = _rag()
|
||||||
|
if rag:
|
||||||
|
medidas["rag"] = rag
|
||||||
|
return medidas
|
||||||
147
nucleo/manos/preguntar.py
Normal file
147
nucleo/manos/preguntar.py
Normal file
|
|
@ -0,0 +1,147 @@
|
||||||
|
"""Que preguntar cuando falta un dato para ejecutar una accion.
|
||||||
|
|
||||||
|
Pulsar una accion en el panel no puede limitarse a recitar la frase que la
|
||||||
|
dispara —"diga «busca el fichero» y a continuacion lo que busca"—: eso es un
|
||||||
|
manual de instrucciones, y uno pulsa justo porque no quiere leerse el manual.
|
||||||
|
Lo natural es que pregunte lo que falta y lo haga.
|
||||||
|
|
||||||
|
busca el fichero -> ¿Que fichero, señor?
|
||||||
|
manda la ventana a la pantalla -> ¿A que pantalla, señor?
|
||||||
|
mata el proceso -> ¿Que proceso, señor?
|
||||||
|
|
||||||
|
## Como sale la pregunta
|
||||||
|
|
||||||
|
Del propio catalogo, no de una lista escrita a mano ni de un modelo. Las frases
|
||||||
|
del catalogo son regulares —verbo + articulo + objeto— asi que basta con buscar
|
||||||
|
el ULTIMO articulo y quedarse con lo que va detras.
|
||||||
|
|
||||||
|
Y se pregunta por el OBJETO, no conjugando el verbo. "¿Que fichero, señor?" es
|
||||||
|
tan natural como "¿Que fichero busco, señor?" y no obliga a conjugar: pasar de
|
||||||
|
"busca" a "busco", de "leeme" a "leo" o de "pon" a "pongo" pide un diccionario
|
||||||
|
de verbos irregulares para ganar nada.
|
||||||
|
|
||||||
|
Si la preposicion viene delante del articulo, se conserva: sin ella, "manda la
|
||||||
|
ventana a la pantalla" preguntaria "¿Que pantalla?" y se pierde el "a", que es
|
||||||
|
justo lo que dice que la respuesta es un destino.
|
||||||
|
"""
|
||||||
|
import re
|
||||||
|
import unicodedata
|
||||||
|
|
||||||
|
ARTICULOS = {"el", "la", "los", "las", "un", "una", "unos", "unas"}
|
||||||
|
# Las contracciones ya llevan la preposicion dentro.
|
||||||
|
CONTRACCIONES = {"al": "a", "del": "de"}
|
||||||
|
PREPOSICIONES = {"a", "de", "en", "con", "por", "para", "sobre", "hacia", "desde"}
|
||||||
|
|
||||||
|
# Cuando no hay de donde sacarlo. Vale para "esta corriendo" o "tengo instalado",
|
||||||
|
# donde el objeto no aparece en la frase.
|
||||||
|
GENERICA = "¿El que, señor?"
|
||||||
|
|
||||||
|
|
||||||
|
def _sin_tildes(t: str) -> str:
|
||||||
|
t = unicodedata.normalize("NFD", t)
|
||||||
|
return "".join(c for c in t if unicodedata.category(c) != "Mn")
|
||||||
|
|
||||||
|
|
||||||
|
def pregunta_por(accion) -> str:
|
||||||
|
"""La pregunta que rellena el hueco de una accion que espera argumento.
|
||||||
|
|
||||||
|
La clave: el argumento va SIEMPRE al final de la frase, porque asi lo
|
||||||
|
recoge el emparejador. Asi que la pregunta se decide mirando como TERMINA.
|
||||||
|
"""
|
||||||
|
frases = getattr(accion, "frases", None) or []
|
||||||
|
if not frases:
|
||||||
|
return GENERICA
|
||||||
|
|
||||||
|
palabras = _sin_tildes(frases[0].lower()).split()
|
||||||
|
if not palabras:
|
||||||
|
return GENERICA
|
||||||
|
ultima = palabras[-1]
|
||||||
|
|
||||||
|
# 1. Termina en preposicion: el hueco va justo detras.
|
||||||
|
# "busca el precio de" -> ¿El precio de que, señor?
|
||||||
|
# "busca imagenes de" -> ¿Imagenes de que, señor?
|
||||||
|
if ultima in PREPOSICIONES:
|
||||||
|
trozo = []
|
||||||
|
# Sin la primera palabra: es el verbo, y en la pregunta sobra.
|
||||||
|
# "busca imagenes de" tiene que dar "¿Imagenes de que?", no
|
||||||
|
# "¿Busca imagenes de que?".
|
||||||
|
for p in reversed(palabras[1:-1]):
|
||||||
|
if p in ARTICULOS or p in CONTRACCIONES:
|
||||||
|
trozo.insert(0, p)
|
||||||
|
break
|
||||||
|
if p in PREPOSICIONES:
|
||||||
|
break
|
||||||
|
trozo.insert(0, p)
|
||||||
|
if len(trozo) >= 2:
|
||||||
|
break
|
||||||
|
if trozo:
|
||||||
|
frase = " ".join(trozo).capitalize()
|
||||||
|
return f"¿{frase} {ultima} que, señor?"
|
||||||
|
return GENERICA
|
||||||
|
|
||||||
|
# 2. "busca en <sitio>": lo que falta es QUE buscar, no el sitio.
|
||||||
|
# Sin esta regla, "busca en la wikipedia" preguntaba "¿En que
|
||||||
|
# wikipedia?", que no tiene sentido: solo hay una.
|
||||||
|
if "en" in palabras:
|
||||||
|
i = palabras.index("en")
|
||||||
|
sitio = " ".join(palabras[i:])
|
||||||
|
verbo = palabras[0]
|
||||||
|
if verbo.startswith("busca"):
|
||||||
|
return f"¿Que busco {sitio}, señor?"
|
||||||
|
return f"¿Que {sitio}, señor?"
|
||||||
|
|
||||||
|
# 3. Lo normal: articulo + objeto al final.
|
||||||
|
# "busca el fichero" -> ¿Que fichero, señor?
|
||||||
|
# "manda la ventana a la pantalla" -> ¿A que pantalla, señor?
|
||||||
|
for i in range(len(palabras) - 1, -1, -1):
|
||||||
|
p = palabras[i]
|
||||||
|
objeto = palabras[i + 1] if i + 1 < len(palabras) else ""
|
||||||
|
if not objeto:
|
||||||
|
continue
|
||||||
|
if p in CONTRACCIONES:
|
||||||
|
return f"¿{CONTRACCIONES[p].capitalize()} que {objeto}, señor?"
|
||||||
|
if p in ARTICULOS:
|
||||||
|
anterior = palabras[i - 1] if i > 0 else ""
|
||||||
|
if anterior in PREPOSICIONES:
|
||||||
|
return f"¿{anterior.capitalize()} que {objeto}, señor?"
|
||||||
|
return f"¿Que {objeto}, señor?"
|
||||||
|
return GENERICA
|
||||||
|
|
||||||
|
|
||||||
|
def confirmacion(accion) -> str:
|
||||||
|
"""Lo que se pregunta antes de algo que no tiene vuelta atras.
|
||||||
|
|
||||||
|
La orden se CITA en vez de meterla en la frase. Las del catalogo estan en
|
||||||
|
imperativo —"cierra el navegador"— y encajarlas da cosas como "Voy a cierra
|
||||||
|
el navegador". Conjugarlas al infinitivo pediria un diccionario de verbos
|
||||||
|
irregulares (cierra->cerrar, pon->poner, ve->ir) para ganar poco: entre
|
||||||
|
comillas se lee bien y ademas queda claro que es literalmente la orden.
|
||||||
|
"""
|
||||||
|
frase = (getattr(accion, "frases", None) or [""])[0]
|
||||||
|
return f"«{frase}». Esto no tiene vuelta atras. ¿Confirma, señor?"
|
||||||
|
|
||||||
|
|
||||||
|
# Lo que cuenta como si y como no. Se comparan sin tildes y sin puntuacion,
|
||||||
|
# porque llegan de Whisper: "sí", "Si.", "SÍ" y "sip" son lo mismo.
|
||||||
|
SI = {"si", "sip", "claro", "vale", "venga", "adelante", "confirmo", "hazlo",
|
||||||
|
"por supuesto", "correcto", "afirmativo", "eso es", "dale", "ok", "okey"}
|
||||||
|
NO = {"no", "nop", "nada", "dejalo", "olvidalo", "cancela", "cancelalo",
|
||||||
|
"para", "mejor no", "negativo", "ni hablar", "espera"}
|
||||||
|
|
||||||
|
|
||||||
|
def es_si(texto: str):
|
||||||
|
"""True si es un si, False si es un no, None si no es ni una cosa ni otra."""
|
||||||
|
limpio = _sin_tildes(re.sub(r"[¡!¿?.,;]", "", (texto or "").lower())).strip()
|
||||||
|
if not limpio:
|
||||||
|
return None
|
||||||
|
if limpio in SI:
|
||||||
|
return True
|
||||||
|
if limpio in NO:
|
||||||
|
return False
|
||||||
|
# Tambien al principio: "si, hazlo" o "no, dejalo"
|
||||||
|
primera = limpio.split()[0]
|
||||||
|
if primera in SI:
|
||||||
|
return True
|
||||||
|
if primera in NO:
|
||||||
|
return False
|
||||||
|
return None
|
||||||
95
nucleo/manos/seleccion.py
Normal file
95
nucleo/manos/seleccion.py
Normal file
|
|
@ -0,0 +1,95 @@
|
||||||
|
"""Elegir de una lista por voz, y buscar dentro de un fichero (Ctrl+F).
|
||||||
|
|
||||||
|
La capa que le faltaba a las acciones de fichero. Buscar y soltar el primer
|
||||||
|
resultado no sirve cuando hay varios: hace falta enseñar la lista y poder decir
|
||||||
|
"abre el tercero". Y para buscar DENTRO de un fichero como con Ctrl+F, hace
|
||||||
|
falta recordar cual era.
|
||||||
|
|
||||||
|
Aqui va la logica pura —interpretar "el tercero", detectar las ordenes de
|
||||||
|
seleccion y de busqueda interna—; el estado (la ultima lista, el ultimo
|
||||||
|
fichero) y la ejecucion viven en el panel.
|
||||||
|
"""
|
||||||
|
import re
|
||||||
|
|
||||||
|
# Como se dice cada posicion. Se aceptan el ordinal, el numero en palabra y la
|
||||||
|
# cifra, porque el reconocedor devuelve cualquiera de los tres.
|
||||||
|
ORDINALES = {
|
||||||
|
1: ["primero", "primera", "uno", "1"],
|
||||||
|
2: ["segundo", "segunda", "dos", "2"],
|
||||||
|
3: ["tercero", "tercera", "tres", "3"],
|
||||||
|
4: ["cuarto", "cuarta", "cuatro", "4"],
|
||||||
|
5: ["quinto", "quinta", "cinco", "5"],
|
||||||
|
6: ["sexto", "sexta", "seis", "6"],
|
||||||
|
7: ["septimo", "septima", "siete", "7"],
|
||||||
|
8: ["octavo", "octava", "ocho", "8"],
|
||||||
|
9: ["noveno", "novena", "nueve", "9"],
|
||||||
|
10: ["decimo", "decima", "diez", "10"],
|
||||||
|
}
|
||||||
|
_PALABRA_A_N = {p: n for n, ps in ORDINALES.items() for p in ps}
|
||||||
|
|
||||||
|
# "el ultimo" es comodo y no es un numero
|
||||||
|
_ULTIMO = {"ultimo", "ultima", "final"}
|
||||||
|
|
||||||
|
|
||||||
|
def posicion(texto: str):
|
||||||
|
"""Devuelve el numero (1..N) que se ha dicho, -1 para 'el ultimo', o None.
|
||||||
|
|
||||||
|
Se queda con la PRIMERA posicion mencionada, para que "abre el tercero"
|
||||||
|
de 3 y no se lie con otros numeros que puedan venir detras.
|
||||||
|
"""
|
||||||
|
for palabra in texto.split():
|
||||||
|
if palabra in _ULTIMO:
|
||||||
|
return -1
|
||||||
|
if palabra in _PALABRA_A_N:
|
||||||
|
return _PALABRA_A_N[palabra]
|
||||||
|
return None
|
||||||
|
|
||||||
|
|
||||||
|
# Ordenes que actuan sobre la lista ya mostrada. El verbo dice que hacer con lo
|
||||||
|
# elegido; la posicion, cual.
|
||||||
|
_ABRIR = re.compile(r"\b(abre|abreme|abrir)\b")
|
||||||
|
_LEER = re.compile(r"\b(lee|leeme|leer|muestrame|ensename)\b")
|
||||||
|
_SELECCION = re.compile(r"\b(el|la|numero|opcion|resultado)\b")
|
||||||
|
|
||||||
|
|
||||||
|
def orden_de_seleccion(texto: str):
|
||||||
|
"""(accion, posicion) si el texto elige de la lista, o None.
|
||||||
|
|
||||||
|
accion: "abrir" o "leer". posicion: 1..N o -1 (ultimo).
|
||||||
|
Ejemplos: "abre el tercero", "lee el numero dos", "el ultimo", "abre el 3".
|
||||||
|
"""
|
||||||
|
pos = posicion(texto)
|
||||||
|
if pos is None:
|
||||||
|
return None
|
||||||
|
# tiene que sonar a seleccion, no a otra cosa que lleve un numero
|
||||||
|
if not (_SELECCION.search(texto) or _ABRIR.search(texto) or _LEER.search(texto)):
|
||||||
|
return None
|
||||||
|
if _LEER.search(texto):
|
||||||
|
return ("leer", pos)
|
||||||
|
# por defecto, elegir es abrir
|
||||||
|
return ("abrir", pos)
|
||||||
|
|
||||||
|
|
||||||
|
# Ctrl+F: buscar un termino dentro del ultimo fichero abierto.
|
||||||
|
_DENTRO = re.compile(
|
||||||
|
r"\b(busca|buscame|encuentra)\b.*\b(dentro|en el fichero|en el archivo|en el texto)\b")
|
||||||
|
|
||||||
|
|
||||||
|
def orden_buscar_dentro(texto: str):
|
||||||
|
"""El termino a buscar dentro del fichero, o None.
|
||||||
|
|
||||||
|
"busca dentro configuracion", "busca en el texto la palabra error".
|
||||||
|
Se queda con lo que va despues de 'dentro'/'en el ...'.
|
||||||
|
"""
|
||||||
|
if not _DENTRO.search(texto):
|
||||||
|
return None
|
||||||
|
# cortar por el separador y quedarse con el resto
|
||||||
|
for sep in ("dentro de", "dentro", "en el fichero", "en el archivo", "en el texto",
|
||||||
|
"la palabra"):
|
||||||
|
if sep in texto:
|
||||||
|
resto = texto.split(sep, 1)[1].strip()
|
||||||
|
resto = re.sub(r"^(la palabra|el termino|de|la|el|los|las)\s+",
|
||||||
|
"", resto).strip()
|
||||||
|
if resto:
|
||||||
|
return resto
|
||||||
|
return None
|
||||||
134
nucleo/manos/sudo_root.py
Normal file
134
nucleo/manos/sudo_root.py
Normal file
|
|
@ -0,0 +1,134 @@
|
||||||
|
"""Ejecutar ordenes como root de forma controlada.
|
||||||
|
|
||||||
|
El problema que resuelve. Newelle convierte `sudo` en `sudo -S` (leer la
|
||||||
|
contraseña de la entrada estandar), pero en el panel de voz no hay una entrada
|
||||||
|
donde teclearla, asi que se queda colgado esperando una contraseña que no
|
||||||
|
llega. Y las acciones marcadas para confirmar no tenian dialogo: solo decian
|
||||||
|
"confirme antes" y no ejecutaban nada.
|
||||||
|
|
||||||
|
Como se resuelve, y las decisiones de seguridad detras:
|
||||||
|
|
||||||
|
- La contraseña NUNCA se escribe en disco. Vive en memoria de este proceso solo
|
||||||
|
si el usuario activa el permiso de sesion, y se pasa a `sudo -S` por stdin.
|
||||||
|
- El permiso de sesion CADUCA: a los 15 minutos de la ultima orden se olvida
|
||||||
|
sola, y tambien al cerrar el panel. No es un "root para siempre".
|
||||||
|
- CADA orden con root muestra su comando exacto en un dialogo antes de correr.
|
||||||
|
El permiso de sesion solo ahorra re-teclear la contraseña, nunca salta el ver
|
||||||
|
y aprobar lo que se va a ejecutar. La voz no puede autoaprobar root.
|
||||||
|
|
||||||
|
Alternativa descartada: apoyarse solo en el timestamp de sudo (`sudo -v`). Es
|
||||||
|
mas limpio en teoria —lo gestiona el sistema— pero a traves de flatpak-spawn el
|
||||||
|
tty cambia entre llamadas y el cacheo no es fiable. Mantener la contraseña en
|
||||||
|
memoria del proceso, con caducidad y sin tocar disco, funciona siempre y el
|
||||||
|
usuario opta a ello de forma explicita.
|
||||||
|
"""
|
||||||
|
import re
|
||||||
|
import subprocess
|
||||||
|
import time
|
||||||
|
|
||||||
|
# A los 15 minutos sin usarla, la contraseña en memoria se olvida. Igual que el
|
||||||
|
# valor por defecto de sudo, para no sorprender.
|
||||||
|
CADUCIDAD = 15 * 60
|
||||||
|
|
||||||
|
# Detecta una invocacion real de sudo: al principio del comando o justo tras un
|
||||||
|
# separador (;, |, &, &&, ||, salto de linea), no la palabra "sudo" dicha como
|
||||||
|
# argumento ("echo sudo no cuenta"). Errar aqui solo pediria una contraseña de
|
||||||
|
# mas, no es peligroso, pero molesta.
|
||||||
|
_SUDO = re.compile(r"(?:^|[;&|\n]|&&|\|\|)\s*sudo(?:\s|$)")
|
||||||
|
|
||||||
|
|
||||||
|
def necesita_root(comando: str) -> bool:
|
||||||
|
"""True si el comando lanza algo con sudo."""
|
||||||
|
return bool(comando and _SUDO.search(comando))
|
||||||
|
|
||||||
|
|
||||||
|
class GestorRoot:
|
||||||
|
"""Guarda —o no— la contraseña de sesion, y ejecuta con ella.
|
||||||
|
|
||||||
|
Una instancia por panel. Al cerrar el panel se llama a olvida().
|
||||||
|
"""
|
||||||
|
|
||||||
|
def __init__(self, prefijo_host=None):
|
||||||
|
# prefijo para salir del sandbox; se pasa como argumento para poder
|
||||||
|
# probar esto sin flatpak
|
||||||
|
self._prefijo = list(prefijo_host or [])
|
||||||
|
self._password = None
|
||||||
|
self._ultimo_uso = 0.0
|
||||||
|
|
||||||
|
# -------------------------------------------------------------- sesion
|
||||||
|
|
||||||
|
def sesion_activa(self) -> bool:
|
||||||
|
"""Hay contraseña recordada y aun no ha caducado."""
|
||||||
|
if self._password is None:
|
||||||
|
return False
|
||||||
|
if time.monotonic() - self._ultimo_uso > CADUCIDAD:
|
||||||
|
self.olvida()
|
||||||
|
return False
|
||||||
|
return True
|
||||||
|
|
||||||
|
def olvida(self):
|
||||||
|
"""Borra la contraseña de memoria. Se llama al cerrar el panel y al
|
||||||
|
caducar. Se sobreescribe antes de soltarla, por si acaso."""
|
||||||
|
if self._password is not None:
|
||||||
|
self._password = "\x00" * len(self._password)
|
||||||
|
self._password = None
|
||||||
|
self._ultimo_uso = 0.0
|
||||||
|
|
||||||
|
def recuerda(self, password: str):
|
||||||
|
self._password = password
|
||||||
|
self._ultimo_uso = time.monotonic()
|
||||||
|
|
||||||
|
# ------------------------------------------------------------ ejecutar
|
||||||
|
|
||||||
|
def valida(self, password: str) -> bool:
|
||||||
|
"""Comprueba la contraseña con `sudo -S -v`, sin ejecutar nada mas.
|
||||||
|
|
||||||
|
-k borra cualquier timestamp previo para que la comprobacion sea de
|
||||||
|
verdad; -v solo actualiza credenciales. Si la contraseña es correcta
|
||||||
|
devuelve True; nunca lanza ningun comando del usuario.
|
||||||
|
"""
|
||||||
|
try:
|
||||||
|
r = subprocess.run(
|
||||||
|
self._prefijo + ["sudo", "-S", "-k", "-p", "", "-v"],
|
||||||
|
input=password + "\n", capture_output=True, text=True,
|
||||||
|
timeout=10)
|
||||||
|
return r.returncode == 0
|
||||||
|
except (OSError, subprocess.SubprocessError):
|
||||||
|
return False
|
||||||
|
|
||||||
|
def ejecuta(self, comando: str, password: str = None, timeout: int = 30):
|
||||||
|
"""Ejecuta el comando dando la contraseña a los sudo que lleve.
|
||||||
|
|
||||||
|
password: si se pasa, se usa esa vez; si no, la de la sesion. La
|
||||||
|
contraseña se pasa por stdin a `sudo -S`. No se registra en ningun
|
||||||
|
sitio.
|
||||||
|
|
||||||
|
Devuelve (salida, codigo). codigo -1 = no habia contraseña disponible.
|
||||||
|
"""
|
||||||
|
clave = password if password is not None else self._password
|
||||||
|
if clave is None:
|
||||||
|
return "No hay contraseña disponible para root.", -1
|
||||||
|
|
||||||
|
# que todos los sudo del comando lean de stdin sin imprimir el prompt
|
||||||
|
preparado = re.sub(r"(^|[;&|]|\s)sudo(\s)",
|
||||||
|
r"\1sudo -S -p '' \2", comando)
|
||||||
|
try:
|
||||||
|
r = subprocess.run(
|
||||||
|
self._prefijo + ["bash", "-lc", preparado],
|
||||||
|
input=clave + "\n", capture_output=True, text=True,
|
||||||
|
timeout=timeout)
|
||||||
|
salida = (r.stdout or r.stderr or "").strip()
|
||||||
|
# sudo escribe su prompt/errores en stderr aunque -p sea vacio;
|
||||||
|
# se limpia lo que es ruido de sudo, no del comando
|
||||||
|
salida = "\n".join(
|
||||||
|
l for l in salida.splitlines()
|
||||||
|
if l.strip() and not l.startswith(("[sudo]", "Sorry, try again")))
|
||||||
|
self._ultimo_uso = time.monotonic()
|
||||||
|
return salida, r.returncode
|
||||||
|
except subprocess.TimeoutExpired:
|
||||||
|
return "La orden con root ha tardado demasiado.", 124
|
||||||
|
except OSError as e:
|
||||||
|
return f"No se pudo ejecutar: {e}", 1
|
||||||
|
finally:
|
||||||
|
# no dejar la copia local viva mas de lo necesario
|
||||||
|
clave = "\x00" * len(clave)
|
||||||
346
nucleo/manos/tareas.py
Normal file
346
nucleo/manos/tareas.py
Normal file
|
|
@ -0,0 +1,346 @@
|
||||||
|
"""Tareas en paralelo: cada orden corre por su cuenta y se puede parar.
|
||||||
|
|
||||||
|
Hasta ahora una orden era una llamada a `ejecuta()`: un `subprocess.run` con
|
||||||
|
veinte segundos de limite que bloqueaba el hilo hasta terminar. Servia porque
|
||||||
|
todos los atajos eran instantaneos, pero deja fuera justo lo que uno querria
|
||||||
|
mandar y olvidarse: un escaneo, una busqueda por todo el disco, una descarga.
|
||||||
|
Y no habia forma de arrepentirse a mitad.
|
||||||
|
|
||||||
|
Aqui cada orden es una Tarea con nombre, estado y un proceso propio del que se
|
||||||
|
guarda el grupo, para poder matarlo entero. Tres cosas que costaron decidir:
|
||||||
|
|
||||||
|
- **Se mata el grupo, no el proceso.** El comando real es `bash -lc "..."`, asi
|
||||||
|
que matar el bash deja vivos a sus hijos —el `find`, el `nmap`— corriendo y
|
||||||
|
comiendo disco con la tarjeta ya cerrada. Con `start_new_session=True` el
|
||||||
|
proceso estrena grupo y `killpg` se los lleva a todos.
|
||||||
|
|
||||||
|
- **Fuera del sandbox tambien vale.** Comprobado: matar el `flatpak-spawn`
|
||||||
|
intermediario propaga la señal al proceso del host (2 procesos vivos -> 0).
|
||||||
|
No hace falta perseguir el PID del otro lado.
|
||||||
|
|
||||||
|
- **La salida se lee segun sale, no al final.** Con `run()` no hay nada que
|
||||||
|
enseñar hasta que termina, y una tarjeta de un escaneo de tres minutos que
|
||||||
|
esta en blanco los tres minutos no informa de nada. Se lee linea a linea y se
|
||||||
|
guardan las ultimas, que es lo que cabe en la tarjeta.
|
||||||
|
"""
|
||||||
|
|
||||||
|
import os
|
||||||
|
import shlex
|
||||||
|
import signal
|
||||||
|
import subprocess
|
||||||
|
import threading
|
||||||
|
import time
|
||||||
|
import urllib.parse
|
||||||
|
|
||||||
|
# Lo que se guarda de la salida para enseñar en la tarjeta y para la plantilla
|
||||||
|
# de respuesta. Una tarjeta pequeña no da para mas, y guardar la salida entera
|
||||||
|
# de un `find /` es meterse megas en memoria por nada.
|
||||||
|
LINEAS_VISTA = 6
|
||||||
|
SALIDA_MAXIMA = 600
|
||||||
|
|
||||||
|
# Con boton de parar, el limite deja de ser una proteccion y pasa a ser un
|
||||||
|
# estorbo: veinte segundos matan cualquier escaneo util. Se deja un tope alto
|
||||||
|
# como red para lo que se cuelgue de verdad y no vuelva nunca.
|
||||||
|
LIMITE_LARGO = 900 # 15 minutos
|
||||||
|
|
||||||
|
# Cada cuanto se avisa al HUD mientras sale texto. Sin freno, un comando
|
||||||
|
# hablador manda cientos de mensajes por segundo al WebView y la interfaz se
|
||||||
|
# atasca dibujando texto que nadie llega a leer.
|
||||||
|
CADENCIA_AVISO = 0.25
|
||||||
|
|
||||||
|
CORRIENDO, HECHA, PARADA, FALLO, CADUCADA = (
|
||||||
|
"corriendo", "hecha", "parada", "fallo", "caducada")
|
||||||
|
|
||||||
|
|
||||||
|
class Tarea:
|
||||||
|
"""Una orden en marcha. Solo datos; quien la mueve es el gestor."""
|
||||||
|
|
||||||
|
def __init__(self, ident, titulo, accion_id, comando):
|
||||||
|
self.id = ident
|
||||||
|
self.titulo = titulo
|
||||||
|
self.accion_id = accion_id
|
||||||
|
self.comando = comando
|
||||||
|
# La accion de origen viaja con la tarea (y no en un diccionario
|
||||||
|
# aparte del panel) porque una tarea sin comando termina DENTRO de
|
||||||
|
# lanza(), antes de que quien la lanzo tenga el id para apuntarla: el
|
||||||
|
# aviso de "terminada" llegaria a un registro todavia vacio.
|
||||||
|
self.accion = None
|
||||||
|
self.argumento = ""
|
||||||
|
self.estado = CORRIENDO
|
||||||
|
self.inicio = time.monotonic()
|
||||||
|
self.fin = None
|
||||||
|
self.lineas = [] # las ultimas LINEAS_VISTA de salida
|
||||||
|
self.salida = "" # la salida acumulada, recortada
|
||||||
|
self.codigo = None
|
||||||
|
self._proc = None
|
||||||
|
|
||||||
|
@property
|
||||||
|
def segundos(self) -> float:
|
||||||
|
return (self.fin or time.monotonic()) - self.inicio
|
||||||
|
|
||||||
|
@property
|
||||||
|
def viva(self) -> bool:
|
||||||
|
return self.estado == CORRIENDO
|
||||||
|
|
||||||
|
def resumen(self) -> dict:
|
||||||
|
"""Lo que viaja al HUD. Sin objetos: esto acaba en un json.dumps."""
|
||||||
|
return {
|
||||||
|
"id": self.id,
|
||||||
|
"titulo": self.titulo,
|
||||||
|
"accion": self.accion_id,
|
||||||
|
"estado": self.estado,
|
||||||
|
"segundos": round(self.segundos, 1),
|
||||||
|
"lineas": self.lineas[-LINEAS_VISTA:],
|
||||||
|
"codigo": self.codigo,
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
class GestorTareas:
|
||||||
|
"""Lanza, vigila y para tareas. Un unico sitio donde vive el registro.
|
||||||
|
|
||||||
|
al_cambiar(tarea) se llama desde el hilo de la tarea cada vez que hay algo
|
||||||
|
nuevo que enseñar. Quien lo reciba se encarga de saltar al hilo de la
|
||||||
|
interfaz: aqui no se sabe nada de GTK a proposito, para poder probarlo sin
|
||||||
|
levantar la aplicacion.
|
||||||
|
"""
|
||||||
|
|
||||||
|
def __init__(self, al_cambiar=None, prefijo_host=()):
|
||||||
|
self._al_cambiar = al_cambiar or (lambda tarea: None)
|
||||||
|
self._prefijo_host = _con_watch_bus(prefijo_host)
|
||||||
|
self._tareas = {}
|
||||||
|
self._siguiente = 0
|
||||||
|
self._cerrojo = threading.Lock()
|
||||||
|
|
||||||
|
# -------------------------------------------------------------- registro
|
||||||
|
|
||||||
|
def _nueva(self, titulo, accion_id, comando) -> Tarea:
|
||||||
|
with self._cerrojo:
|
||||||
|
self._siguiente += 1
|
||||||
|
ident = f"t{self._siguiente}"
|
||||||
|
tarea = Tarea(ident, titulo, accion_id, comando)
|
||||||
|
self._tareas[ident] = tarea
|
||||||
|
return tarea
|
||||||
|
|
||||||
|
def get(self, ident):
|
||||||
|
with self._cerrojo:
|
||||||
|
return self._tareas.get(ident)
|
||||||
|
|
||||||
|
def activas(self) -> list:
|
||||||
|
with self._cerrojo:
|
||||||
|
return [t for t in self._tareas.values() if t.viva]
|
||||||
|
|
||||||
|
def todas(self) -> list:
|
||||||
|
with self._cerrojo:
|
||||||
|
return list(self._tareas.values())
|
||||||
|
|
||||||
|
def _avisa(self, tarea):
|
||||||
|
try:
|
||||||
|
self._al_cambiar(tarea)
|
||||||
|
except Exception as e: # el HUD no tumba la tarea
|
||||||
|
print(f"JARVIS: aviso de tarea fallido: {e}")
|
||||||
|
|
||||||
|
# ---------------------------------------------------------------- lanzar
|
||||||
|
|
||||||
|
def lanza(self, accion, argumento="", titulo=None) -> Tarea:
|
||||||
|
"""Arranca la accion en su propio proceso y devuelve la tarea ya viva."""
|
||||||
|
comando = accion.comando or ""
|
||||||
|
if comando:
|
||||||
|
comando = comando.replace("{argumento}", shlex.quote(argumento))
|
||||||
|
comando = comando.replace(
|
||||||
|
"{argumento_url}",
|
||||||
|
shlex.quote(urllib.parse.quote_plus(argumento)))
|
||||||
|
|
||||||
|
tarea = self._nueva(titulo or _titulo_de(accion, argumento),
|
||||||
|
accion.id, comando)
|
||||||
|
tarea.accion = accion
|
||||||
|
tarea.argumento = argumento
|
||||||
|
self._avisa(tarea)
|
||||||
|
|
||||||
|
if not comando:
|
||||||
|
# Acciones que solo hablan (no tienen comando): nacen terminadas.
|
||||||
|
self.termina(tarea.id, HECHA, "")
|
||||||
|
return tarea
|
||||||
|
|
||||||
|
orden = ["bash", "-lc", comando]
|
||||||
|
if accion.host:
|
||||||
|
orden = self._prefijo_host + orden
|
||||||
|
|
||||||
|
threading.Thread(target=self._corre, args=(tarea, orden),
|
||||||
|
daemon=True).start()
|
||||||
|
return tarea
|
||||||
|
|
||||||
|
def adopta(self, titulo, accion_id="") -> Tarea:
|
||||||
|
"""Una tarjeta para trabajo que se ejecuta fuera del gestor.
|
||||||
|
|
||||||
|
Lo que pasa por el dialogo de root corre por su camino (GestorRoot, con
|
||||||
|
su contraseña), pero se merece tarjeta igual: si no, pedir algo con
|
||||||
|
sudo hace desaparecer la señal de que hay algo en marcha.
|
||||||
|
"""
|
||||||
|
tarea = self._nueva(titulo, accion_id, "")
|
||||||
|
self._avisa(tarea)
|
||||||
|
return tarea
|
||||||
|
|
||||||
|
def _corre(self, tarea, orden):
|
||||||
|
try:
|
||||||
|
# start_new_session: el proceso estrena grupo, para poder matar el
|
||||||
|
# arbol entero y no solo el bash de arriba.
|
||||||
|
proc = subprocess.Popen(
|
||||||
|
orden, stdout=subprocess.PIPE, stderr=subprocess.STDOUT,
|
||||||
|
text=True, errors="replace", start_new_session=True)
|
||||||
|
except OSError as e:
|
||||||
|
self.termina(tarea.id, FALLO, f"No he podido ejecutarlo: {e}")
|
||||||
|
return
|
||||||
|
|
||||||
|
tarea._proc = proc
|
||||||
|
limite = threading.Timer(LIMITE_LARGO, self._caduca, args=(tarea.id,))
|
||||||
|
limite.daemon = True
|
||||||
|
limite.start()
|
||||||
|
|
||||||
|
ultimo_aviso = 0.0
|
||||||
|
acumulado = []
|
||||||
|
try:
|
||||||
|
for linea in proc.stdout:
|
||||||
|
linea = linea.rstrip("\n")
|
||||||
|
if not linea.strip():
|
||||||
|
continue
|
||||||
|
acumulado.append(linea)
|
||||||
|
tarea.lineas = acumulado[-LINEAS_VISTA:]
|
||||||
|
ahora = time.monotonic()
|
||||||
|
if ahora - ultimo_aviso >= CADENCIA_AVISO:
|
||||||
|
ultimo_aviso = ahora
|
||||||
|
self._avisa(tarea)
|
||||||
|
except Exception as e:
|
||||||
|
print(f"JARVIS: leyendo la salida de {tarea.id}: {e}")
|
||||||
|
finally:
|
||||||
|
limite.cancel()
|
||||||
|
|
||||||
|
codigo = proc.wait()
|
||||||
|
salida = "\n".join(acumulado).strip()
|
||||||
|
|
||||||
|
if tarea.estado == PARADA: # la paro alguien: no se toca
|
||||||
|
self._avisa(tarea)
|
||||||
|
return
|
||||||
|
if tarea.estado == CADUCADA:
|
||||||
|
self._avisa(tarea)
|
||||||
|
return
|
||||||
|
self.termina(tarea.id, HECHA if codigo == 0 else FALLO, salida, codigo)
|
||||||
|
|
||||||
|
# ------------------------------------------------------------- terminar
|
||||||
|
|
||||||
|
def termina(self, ident, estado, salida="", codigo=None):
|
||||||
|
tarea = self.get(ident)
|
||||||
|
if tarea is None:
|
||||||
|
return
|
||||||
|
tarea.estado = estado
|
||||||
|
tarea.fin = time.monotonic()
|
||||||
|
tarea.codigo = codigo
|
||||||
|
if salida:
|
||||||
|
tarea.salida = salida[:SALIDA_MAXIMA]
|
||||||
|
if not tarea.lineas:
|
||||||
|
tarea.lineas = salida.splitlines()[-LINEAS_VISTA:]
|
||||||
|
else:
|
||||||
|
tarea.salida = "\n".join(tarea.lineas)[:SALIDA_MAXIMA]
|
||||||
|
self._avisa(tarea)
|
||||||
|
|
||||||
|
def para(self, ident) -> bool:
|
||||||
|
"""Corta la tarea. Primero por las buenas, luego a la fuerza."""
|
||||||
|
tarea = self.get(ident)
|
||||||
|
if tarea is None or not tarea.viva:
|
||||||
|
return False
|
||||||
|
|
||||||
|
tarea.estado = PARADA
|
||||||
|
proc = tarea._proc
|
||||||
|
if proc is not None and proc.poll() is None:
|
||||||
|
_mata_grupo(proc)
|
||||||
|
tarea.fin = time.monotonic()
|
||||||
|
self._avisa(tarea)
|
||||||
|
return True
|
||||||
|
|
||||||
|
def _caduca(self, ident):
|
||||||
|
tarea = self.get(ident)
|
||||||
|
if tarea is None or not tarea.viva:
|
||||||
|
return
|
||||||
|
tarea.estado = CADUCADA
|
||||||
|
if tarea._proc is not None and tarea._proc.poll() is None:
|
||||||
|
_mata_grupo(tarea._proc)
|
||||||
|
tarea.fin = time.monotonic()
|
||||||
|
self._avisa(tarea)
|
||||||
|
|
||||||
|
def cierra(self, ident) -> bool:
|
||||||
|
"""Quita la tarjeta. Si seguia viva, la para antes: cerrar es cerrar."""
|
||||||
|
tarea = self.get(ident)
|
||||||
|
if tarea is None:
|
||||||
|
return False
|
||||||
|
if tarea.viva:
|
||||||
|
self.para(ident)
|
||||||
|
with self._cerrojo:
|
||||||
|
self._tareas.pop(ident, None)
|
||||||
|
return True
|
||||||
|
|
||||||
|
def para_todas(self):
|
||||||
|
for tarea in self.activas():
|
||||||
|
self.para(tarea.id)
|
||||||
|
|
||||||
|
|
||||||
|
def _con_watch_bus(prefijo) -> list:
|
||||||
|
"""Que lo lanzado fuera del sandbox no sobreviva a la aplicacion.
|
||||||
|
|
||||||
|
Una tarea larga corre en el host por flatpak-spawn, y ahi el proceso ya no
|
||||||
|
es hijo de nadie que se entere de que la app se ha cerrado: un escaneo
|
||||||
|
lanzado y olvidado seguiria comiendo maquina despues de cerrar la ventana,
|
||||||
|
sin ventana desde la que pararlo. `--watch-bus` ata su vida a la conexion
|
||||||
|
de bus de quien lo lanzo, que es justo lo que se quiere.
|
||||||
|
"""
|
||||||
|
prefijo = list(prefijo)
|
||||||
|
if not prefijo:
|
||||||
|
return prefijo
|
||||||
|
if any("flatpak-spawn" in p for p in prefijo) and "--watch-bus" not in prefijo:
|
||||||
|
# detras del propio flatpak-spawn, antes de sus argumentos
|
||||||
|
for i, p in enumerate(prefijo):
|
||||||
|
if "flatpak-spawn" in p:
|
||||||
|
prefijo.insert(i + 1, "--watch-bus")
|
||||||
|
break
|
||||||
|
return prefijo
|
||||||
|
|
||||||
|
|
||||||
|
def _mata_grupo(proc):
|
||||||
|
"""SIGTERM al grupo, y SIGKILL a los tres segundos si sigue ahi.
|
||||||
|
|
||||||
|
Se da margen a proposito: un `wget` a medias cierra el fichero y un `nmap`
|
||||||
|
escupe lo que llevaba. Matar a lo bruto de entrada deja restos.
|
||||||
|
"""
|
||||||
|
try:
|
||||||
|
grupo = os.getpgid(proc.pid)
|
||||||
|
except OSError:
|
||||||
|
return
|
||||||
|
try:
|
||||||
|
os.killpg(grupo, signal.SIGTERM)
|
||||||
|
except OSError:
|
||||||
|
return
|
||||||
|
|
||||||
|
def remata():
|
||||||
|
if proc.poll() is None:
|
||||||
|
try:
|
||||||
|
os.killpg(grupo, signal.SIGKILL)
|
||||||
|
except OSError:
|
||||||
|
pass
|
||||||
|
|
||||||
|
t = threading.Timer(3.0, remata)
|
||||||
|
t.daemon = True
|
||||||
|
t.start()
|
||||||
|
|
||||||
|
|
||||||
|
def _titulo_de(accion, argumento) -> str:
|
||||||
|
"""El rotulo de la tarjeta: corto, y con el argumento si lo hay.
|
||||||
|
|
||||||
|
El id de la accion con guiones bajos ("buscar_fichero") es de programador;
|
||||||
|
en la tarjeta se lee "buscar fichero", y con lo que se pidio detras, que es
|
||||||
|
lo que distingue dos busquedas a la vez.
|
||||||
|
"""
|
||||||
|
base = (accion.id or "accion").replace("_", " ")
|
||||||
|
if argumento:
|
||||||
|
arg = argumento.strip()
|
||||||
|
if len(arg) > 22:
|
||||||
|
arg = arg[:21] + "…"
|
||||||
|
return f"{base}: {arg}"
|
||||||
|
return base
|
||||||
182
nucleo/mejora.py
Executable file
182
nucleo/mejora.py
Executable file
|
|
@ -0,0 +1,182 @@
|
||||||
|
#!/usr/bin/env python3
|
||||||
|
"""Que ha aprendido JARVIS del uso, y que conviene cambiar.
|
||||||
|
|
||||||
|
./mejora.py que hay en el diario
|
||||||
|
./mejora.py --propone que acciones o frases faltan
|
||||||
|
./mejora.py --mide cuanto acierta ahora mismo
|
||||||
|
|
||||||
|
## En que se diferencia de la mejora nocturna que se retiro
|
||||||
|
|
||||||
|
La de antes corria sola de madrugada, se modificaba el codigo y se commiteaba.
|
||||||
|
Nueve horas, 39 rondas, cero commits utiles. Fallo por tres cosas, y las tres
|
||||||
|
estan corregidas aqui:
|
||||||
|
|
||||||
|
1. **Minaba ruido.** Su fuente era un registro donde el 60 % era JARVIS
|
||||||
|
oyendose a si mismo y alucinaciones de Whisper. Ahora la guarda del eco y
|
||||||
|
el filtro de ruido limpian antes, y el diario apunta la VIA de cada frase,
|
||||||
|
asi que el ruido esta separado y etiquetado en vez de mezclado.
|
||||||
|
|
||||||
|
2. **Su medida tenia mas ruido que su mejora.** Generaba audio nuevo cada
|
||||||
|
ronda: ±1,9 puntos de ruido contra +1,45 de mejora acumulada, o sea que
|
||||||
|
"¿esto mejora o empeora?" se decidia a cara o cruz. Ahora se mide contra
|
||||||
|
`datos/banco.json`, que es fijo y determinista.
|
||||||
|
|
||||||
|
3. **Actuaba sola.** Un bucle que se reescribe y se aprueba a si mismo acaba
|
||||||
|
pasando siempre. Esto PROPONE y para: lo que se aplica lo decide una
|
||||||
|
persona mirandolo.
|
||||||
|
|
||||||
|
Y una cuarta, de fondo: aquella tocaba el codigo. Esta solo mira el catalogo,
|
||||||
|
que es lo unico que se puede validar de verdad con el banco.
|
||||||
|
"""
|
||||||
|
import argparse
|
||||||
|
import collections
|
||||||
|
import os
|
||||||
|
import sys
|
||||||
|
|
||||||
|
AQUI = os.path.dirname(os.path.abspath(__file__))
|
||||||
|
sys.path.insert(0, AQUI)
|
||||||
|
|
||||||
|
from manos import Manos # noqa: E402
|
||||||
|
from manos.acciones import normaliza, parecido # noqa: E402
|
||||||
|
from manos.diario import lee # noqa: E402
|
||||||
|
|
||||||
|
|
||||||
|
def color(t, c):
|
||||||
|
return f"\033[{c}m{t}\033[0m" if sys.stdout.isatty() else t
|
||||||
|
|
||||||
|
|
||||||
|
# ------------------------------------------------------------------ mirar
|
||||||
|
|
||||||
|
def resumen(lineas):
|
||||||
|
if not lineas:
|
||||||
|
print(" el diario esta vacio: usa JARVIS un rato y vuelve")
|
||||||
|
return 1
|
||||||
|
|
||||||
|
vias = collections.Counter(l.get("via", "?") for l in lineas)
|
||||||
|
tot = sum(vias.values())
|
||||||
|
print(f"\n {tot} frases desde {lineas[0]['t'][:10]}\n")
|
||||||
|
print(f" {'via':14s} {'n':>5s} {'%':>7s}")
|
||||||
|
print(" " + "-" * 32)
|
||||||
|
ORDEN = ["catalogo", "cerebro", "respuesta", "ruido", "sin-nombre",
|
||||||
|
"bloqueado", "sin-cerebro"]
|
||||||
|
for v in ORDEN + [k for k in vias if k not in ORDEN]:
|
||||||
|
if v in vias:
|
||||||
|
print(f" {v:14s} {vias[v]:5d} {100*vias[v]/tot:6.1f} %")
|
||||||
|
|
||||||
|
atendidas = vias["catalogo"] + vias["cerebro"]
|
||||||
|
if atendidas:
|
||||||
|
print(f"\n de lo ATENDIDO ({atendidas}), el catalogo cogio "
|
||||||
|
f"{100*vias['catalogo']/atendidas:.0f} %")
|
||||||
|
segs = [l.get("seg", 0) for l in lineas if l.get("via") == "catalogo"]
|
||||||
|
segc = [l.get("seg", 0) for l in lineas if l.get("via") == "cerebro"]
|
||||||
|
if segs:
|
||||||
|
print(f" catalogo: {sum(segs)/len(segs):.2f} s de media")
|
||||||
|
if segc:
|
||||||
|
print(f" cerebro: {sum(segc)/len(segc):.1f} s de media")
|
||||||
|
ahorro = (sum(segc)/len(segc) - (sum(segs)/len(segs) if segs else 0))
|
||||||
|
print(f"\n cada accion que se añada al catalogo ahorra ~{ahorro:.0f} s")
|
||||||
|
|
||||||
|
top = collections.Counter(l["accion"] for l in lineas
|
||||||
|
if l.get("via") == "catalogo" and l.get("accion"))
|
||||||
|
if top:
|
||||||
|
print("\n lo que mas usas:")
|
||||||
|
for a, n in top.most_common(8):
|
||||||
|
print(f" {n:4d} {a}")
|
||||||
|
return 0
|
||||||
|
|
||||||
|
|
||||||
|
# --------------------------------------------------------------- proponer
|
||||||
|
|
||||||
|
def propone(lineas, manos):
|
||||||
|
"""Lo que fue al cerebro y podria ser una accion del catalogo."""
|
||||||
|
# "sin-cerebro" cuenta igual: es lo mismo —una frase que el catalogo no
|
||||||
|
# cubrio— y solo se diferencia en que no habia modelo conectado para
|
||||||
|
# atenderla. El hueco del catalogo es el mismo.
|
||||||
|
alCerebro = [l for l in lineas if l.get("via") in ("cerebro", "sin-cerebro")]
|
||||||
|
if not alCerebro:
|
||||||
|
print("\n nada ha ido al cerebro todavia: no hay hueco que rellenar")
|
||||||
|
return 0
|
||||||
|
|
||||||
|
# Agrupar lo parecido: si has pedido lo mismo de tres formas, es UNA accion
|
||||||
|
# que falta, no tres. Y que lo hayas repetido es justo la señal de que
|
||||||
|
# importa.
|
||||||
|
grupos = []
|
||||||
|
for l in alCerebro:
|
||||||
|
t = normaliza(l["oido"])
|
||||||
|
if len(t.split()) < 2:
|
||||||
|
continue
|
||||||
|
for g in grupos:
|
||||||
|
if parecido(t, g["patron"]) > 0.62:
|
||||||
|
g["frases"].append(l["oido"])
|
||||||
|
break
|
||||||
|
else:
|
||||||
|
grupos.append({"patron": t, "frases": [l["oido"]],
|
||||||
|
"dicho": l.get("dicho", "")})
|
||||||
|
|
||||||
|
grupos.sort(key=lambda g: -len(g["frases"]))
|
||||||
|
print(f"\n {len(alCerebro)} frases fueron al cerebro, en {len(grupos)} grupos.")
|
||||||
|
print(" Las que mas se repiten son las acciones que faltan:\n")
|
||||||
|
|
||||||
|
for g in grupos[:12]:
|
||||||
|
n = len(g["frases"])
|
||||||
|
marca = color(f"{n:3d} veces", "33" if n > 1 else "90")
|
||||||
|
print(f" {marca} {g['frases'][0][:64]}")
|
||||||
|
for f in g["frases"][1:4]:
|
||||||
|
print(f" {color('tambien: ' + f[:56], '90')}")
|
||||||
|
if g["dicho"]:
|
||||||
|
print(f" {color('contesto: ' + g['dicho'][:56], '90')}")
|
||||||
|
print()
|
||||||
|
|
||||||
|
repetidas = [g for g in grupos if len(g["frases"]) > 1]
|
||||||
|
print(f" {len(repetidas)} se han pedido mas de una vez: por ahi empezaria.\n")
|
||||||
|
print(color(" Esto NO cambia nada. Para añadir una accion se edita\n"
|
||||||
|
" datos/_generar.py —que es la FUENTE— y se regenera.\n", "90"))
|
||||||
|
return 0
|
||||||
|
|
||||||
|
|
||||||
|
# ------------------------------------------------------------------ medir
|
||||||
|
|
||||||
|
def mide(manos):
|
||||||
|
"""El acierto del emparejador contra el banco fijo."""
|
||||||
|
import json
|
||||||
|
banco = os.path.join(AQUI, "datos", "banco.json")
|
||||||
|
try:
|
||||||
|
with open(banco, encoding="utf-8") as f:
|
||||||
|
casos = json.load(f)["casos"]
|
||||||
|
except OSError:
|
||||||
|
print(" no hay banco: pruebas/banco.py --crear")
|
||||||
|
return 1
|
||||||
|
bien = otra = 0
|
||||||
|
for c in casos:
|
||||||
|
a, _ = manos.busca(c["oido"])
|
||||||
|
if a is None:
|
||||||
|
continue
|
||||||
|
if a.id == c["id"]:
|
||||||
|
bien += 1
|
||||||
|
else:
|
||||||
|
otra += 1
|
||||||
|
print(f"\n acierto {100*bien/len(casos):.1f} % sobre {len(casos)} frases")
|
||||||
|
print(f" ordenes que acaban en la accion equivocada: {otra}")
|
||||||
|
print(color("\n Este numero es comparable entre dias: el banco esta grabado\n"
|
||||||
|
" una vez y no cambia. Era lo que le faltaba a la mejora\n"
|
||||||
|
" nocturna, cuyo ruido de medida era mayor que su mejora.\n", "90"))
|
||||||
|
return 0
|
||||||
|
|
||||||
|
|
||||||
|
def main() -> int:
|
||||||
|
p = argparse.ArgumentParser(description="Que ha aprendido JARVIS del uso")
|
||||||
|
p.add_argument("--propone", action="store_true")
|
||||||
|
p.add_argument("--mide", action="store_true")
|
||||||
|
a = p.parse_args()
|
||||||
|
|
||||||
|
manos = Manos()
|
||||||
|
lineas = lee()
|
||||||
|
if a.mide:
|
||||||
|
return mide(manos)
|
||||||
|
if a.propone:
|
||||||
|
return propone(lineas, manos)
|
||||||
|
return resumen(lineas)
|
||||||
|
|
||||||
|
|
||||||
|
if __name__ == "__main__":
|
||||||
|
sys.exit(main())
|
||||||
0
nucleo/oido/__init__.py
Normal file
0
nucleo/oido/__init__.py
Normal file
188
nucleo/oido/captura.py
Normal file
188
nucleo/oido/captura.py
Normal file
|
|
@ -0,0 +1,188 @@
|
||||||
|
"""Escuchar el microfono y recortar lo que es habla.
|
||||||
|
|
||||||
|
## Por que pw-record y no pyaudio
|
||||||
|
|
||||||
|
Newelle usa pyaudio, que necesita portaudio compilado. En esta maquina no esta,
|
||||||
|
asi que instalarlo pediria sudo. `pw-record` y `parec` ya vienen con PipeWire y
|
||||||
|
sirven igual: se lanzan como subproceso y se lee su salida estandar.
|
||||||
|
|
||||||
|
Y hay una ventaja que no es casual: la fuente se elige con un argumento. Cuando
|
||||||
|
se ponga el cancelador de eco de PipeWire, apuntar ahi es cambiar una cadena, no
|
||||||
|
tocar codigo de audio.
|
||||||
|
|
||||||
|
## La guarda contra el eco
|
||||||
|
|
||||||
|
Esta es la razon de ser de este fichero. En Newelle, el 21 % largo de lo que
|
||||||
|
JARVIS oye y no entiende es su propia voz. Tiene mecanismo para evitarlo pero
|
||||||
|
con tres agujeros, y aqui se cierran los tres:
|
||||||
|
|
||||||
|
1. **Se consulta a la boca en cada trozo**, no una bandera que alguien actualiza
|
||||||
|
desde otro hilo. Si `boca.hablando` es cierto, ese audio se tira sin mirar.
|
||||||
|
2. **La cola de 350 ms** vive en la boca (`COLA_MS`): cuando el reproductor
|
||||||
|
termina, el sonido sigue llegando al microfono un rato.
|
||||||
|
3. **El prebufer se vacia** al salir de "hablando". Newelle guarda 1 s circular
|
||||||
|
y lo antepone al detectar voz; ese segundo era justo el final de la frase de
|
||||||
|
JARVIS, asi que se colaba aunque la guarda funcionase.
|
||||||
|
"""
|
||||||
|
import collections
|
||||||
|
import os
|
||||||
|
import signal
|
||||||
|
import struct
|
||||||
|
import subprocess
|
||||||
|
import tempfile
|
||||||
|
import wave
|
||||||
|
|
||||||
|
FRECUENCIA = 16000 # lo que quiere whisper.cpp
|
||||||
|
CANALES = 1
|
||||||
|
ANCHO = 2 # s16
|
||||||
|
TROZO = 512 # muestras: lo que pide Silero de una vez
|
||||||
|
|
||||||
|
# Cuanto silencio hace falta para dar la frase por terminada. Muy corto corta a
|
||||||
|
# quien piensa a media frase; muy largo hace que JARVIS parezca lento.
|
||||||
|
SILENCIO_PARA_CERRAR = 0.8
|
||||||
|
# Cuanto se guarda de ANTES de detectar voz. La primera silaba siempre llega
|
||||||
|
# antes de que el detector se entere.
|
||||||
|
PREBUFER_S = 0.5
|
||||||
|
# Frases mas cortas que esto no son ordenes, son ruidos.
|
||||||
|
MINIMO_S = 0.35
|
||||||
|
# Y mas largas que esto es que el detector se ha quedado enganchado.
|
||||||
|
MAXIMO_S = 25.0
|
||||||
|
|
||||||
|
|
||||||
|
def _grabador(fuente=None):
|
||||||
|
"""La orden para capturar crudo a la salida estandar."""
|
||||||
|
if fuente:
|
||||||
|
pw = ["pw-record", "--target", fuente]
|
||||||
|
else:
|
||||||
|
pw = ["pw-record"]
|
||||||
|
return pw + ["--rate", str(FRECUENCIA), "--channels", str(CANALES),
|
||||||
|
"--format", "s16", "-"]
|
||||||
|
|
||||||
|
|
||||||
|
class Captura:
|
||||||
|
"""Trozos de microfono -> frases sueltas en WAV."""
|
||||||
|
|
||||||
|
def __init__(self, boca=None, fuente=None, agresividad=0.5):
|
||||||
|
self.boca = boca # para saber si JARVIS esta hablando
|
||||||
|
self.fuente = fuente
|
||||||
|
self.agresividad = agresividad
|
||||||
|
self._proc = None
|
||||||
|
self._vad = None
|
||||||
|
self._energia = None
|
||||||
|
|
||||||
|
# ------------------------------------------------------------ el detector
|
||||||
|
|
||||||
|
def _detector(self):
|
||||||
|
if self._vad is not None or self._energia is not None:
|
||||||
|
return
|
||||||
|
try:
|
||||||
|
from pysilero_vad import SileroVoiceActivityDetector
|
||||||
|
self._vad = SileroVoiceActivityDetector()
|
||||||
|
except Exception:
|
||||||
|
# Respaldo por energia: peor, pero mejor que no escuchar. Se avisa,
|
||||||
|
# porque la diferencia se nota y conviene saber en cual se esta.
|
||||||
|
print("oido: sin Silero, usando deteccion por energia")
|
||||||
|
self._energia = True
|
||||||
|
|
||||||
|
def _hay_voz(self, trozo: bytes) -> bool:
|
||||||
|
if self._vad is not None:
|
||||||
|
try:
|
||||||
|
return self._vad(trozo) >= self.agresividad
|
||||||
|
except Exception:
|
||||||
|
return False
|
||||||
|
muestras = struct.unpack(f"{len(trozo) // 2}h", trozo)
|
||||||
|
if not muestras:
|
||||||
|
return False
|
||||||
|
media = sum(m * m for m in muestras) / len(muestras)
|
||||||
|
return (media ** 0.5) / 32768.0 > 0.015
|
||||||
|
|
||||||
|
# -------------------------------------------------------------- escuchar
|
||||||
|
|
||||||
|
def frases(self, para_cuando=None):
|
||||||
|
"""Generador: devuelve la ruta de un WAV por cada frase oida.
|
||||||
|
|
||||||
|
El WAV es temporal y de quien lo recibe: se borra cuando quiera.
|
||||||
|
"""
|
||||||
|
self._detector()
|
||||||
|
self._proc = subprocess.Popen(
|
||||||
|
_grabador(self.fuente), stdout=subprocess.PIPE,
|
||||||
|
stderr=subprocess.DEVNULL, start_new_session=True)
|
||||||
|
|
||||||
|
bytes_trozo = TROZO * ANCHO
|
||||||
|
por_segundo = FRECUENCIA / TROZO
|
||||||
|
prebufer = collections.deque(maxlen=max(1, int(PREBUFER_S * por_segundo)))
|
||||||
|
cerrar_tras = int(SILENCIO_PARA_CERRAR * por_segundo)
|
||||||
|
tope = int(MAXIMO_S * por_segundo)
|
||||||
|
|
||||||
|
frase, callados, hablando = [], 0, False
|
||||||
|
try:
|
||||||
|
while True:
|
||||||
|
if para_cuando and para_cuando():
|
||||||
|
break
|
||||||
|
trozo = self._proc.stdout.read(bytes_trozo)
|
||||||
|
if not trozo or len(trozo) < bytes_trozo:
|
||||||
|
break
|
||||||
|
|
||||||
|
# --- la guarda: si JARVIS habla, esto es su propia voz -------
|
||||||
|
if self.boca is not None and self.boca.hablando:
|
||||||
|
# Tirar tambien lo acumulado: si estaba a media frase cuando
|
||||||
|
# JARVIS empezo a hablar, lo que quede lleva su voz encima.
|
||||||
|
prebufer.clear()
|
||||||
|
frase, callados, hablando = [], 0, False
|
||||||
|
continue
|
||||||
|
|
||||||
|
prebufer.append(trozo)
|
||||||
|
voz = self._hay_voz(trozo)
|
||||||
|
|
||||||
|
if voz and not hablando:
|
||||||
|
hablando = True
|
||||||
|
frase = list(prebufer) # con lo de antes de detectarla
|
||||||
|
callados = 0
|
||||||
|
elif hablando:
|
||||||
|
frase.append(trozo)
|
||||||
|
callados = 0 if voz else callados + 1
|
||||||
|
|
||||||
|
if hablando and (callados >= cerrar_tras or len(frase) >= tope):
|
||||||
|
dur = len(frase) * TROZO / FRECUENCIA
|
||||||
|
ruta = self._a_wav(frase) if dur >= MINIMO_S else None
|
||||||
|
frase, callados, hablando = [], 0, False
|
||||||
|
prebufer.clear()
|
||||||
|
if ruta:
|
||||||
|
yield ruta
|
||||||
|
finally:
|
||||||
|
self.para()
|
||||||
|
|
||||||
|
def _a_wav(self, trozos) -> str:
|
||||||
|
fd, ruta = tempfile.mkstemp(suffix=".wav", prefix="jarvis-oido-")
|
||||||
|
os.close(fd)
|
||||||
|
with wave.open(ruta, "wb") as w:
|
||||||
|
w.setnchannels(CANALES)
|
||||||
|
w.setsampwidth(ANCHO)
|
||||||
|
w.setframerate(FRECUENCIA)
|
||||||
|
w.writeframes(b"".join(trozos))
|
||||||
|
return ruta
|
||||||
|
|
||||||
|
def para(self):
|
||||||
|
if not self._proc:
|
||||||
|
return
|
||||||
|
try:
|
||||||
|
os.killpg(os.getpgid(self._proc.pid), signal.SIGTERM)
|
||||||
|
self._proc.wait(timeout=3)
|
||||||
|
except Exception:
|
||||||
|
pass
|
||||||
|
self._proc = None
|
||||||
|
|
||||||
|
|
||||||
|
def fuentes() -> list:
|
||||||
|
"""Las entradas que hay, para poder elegir la del cancelador de eco."""
|
||||||
|
try:
|
||||||
|
r = subprocess.run(["pactl", "list", "short", "sources"],
|
||||||
|
capture_output=True, text=True, timeout=10)
|
||||||
|
except (OSError, subprocess.TimeoutExpired):
|
||||||
|
return []
|
||||||
|
salida = []
|
||||||
|
for linea in r.stdout.splitlines():
|
||||||
|
campos = linea.split("\t")
|
||||||
|
if len(campos) > 1 and not campos[1].endswith(".monitor"):
|
||||||
|
salida.append(campos[1])
|
||||||
|
return salida
|
||||||
143
nucleo/oido/despierta.py
Normal file
143
nucleo/oido/despierta.py
Normal file
|
|
@ -0,0 +1,143 @@
|
||||||
|
"""La palabra de activacion: "JARVIS".
|
||||||
|
|
||||||
|
Sin esto, el asistente obedece a cualquier cosa que se diga en la habitacion —y
|
||||||
|
a la tele—. Con esto, solo escucha de verdad durante un rato despues de oir su
|
||||||
|
nombre.
|
||||||
|
|
||||||
|
## Por que sobre el texto y no sobre el audio
|
||||||
|
|
||||||
|
Lo obvio seria un detector como openwakeword, que mira la forma de onda antes de
|
||||||
|
transcribir. Aqui se hace despues, sobre lo que Whisper ya escribio, y es a
|
||||||
|
proposito:
|
||||||
|
|
||||||
|
- **Ya tenemos la transcripcion.** El audio pasa por Whisper de todas formas
|
||||||
|
porque la captura la dispara el detector de voz; no hay ahorro que ganar.
|
||||||
|
- **Un modelo menos.** openwakeword son mas dependencias, otro modelo en
|
||||||
|
memoria y otro afinado que mantener.
|
||||||
|
- **Y sobre todo: Whisper oye "JARVIS" de mil maneras.** Medido en el registro
|
||||||
|
de uso real, el nombre sale como "Jarvis", "Yarvis", "Charles", "Chavez",
|
||||||
|
"Harvest"... Sobre el texto eso se arregla comparando como SUENA, que es lo
|
||||||
|
que ya hace `manos/fonetica.py` para el catalogo. Sobre la onda habria que
|
||||||
|
reentrenar.
|
||||||
|
|
||||||
|
Lo que se pierde: la transcripcion corre siempre, tambien cuando nadie ha
|
||||||
|
llamado. En una maquina donde Whisper va en la grafica y tarda dos segundos, es
|
||||||
|
un coste que ya estabamos pagando.
|
||||||
|
|
||||||
|
## Como se comporta
|
||||||
|
|
||||||
|
Se llama una vez y se queda despierto un rato, para poder encadenar ordenes sin
|
||||||
|
repetir el nombre en cada frase. Y si la frase que trae el nombre lleva ademas
|
||||||
|
la orden —"JARVIS, cuanto espacio queda"— se atiende esa misma, sin obligar a
|
||||||
|
decirlo dos veces.
|
||||||
|
"""
|
||||||
|
import difflib
|
||||||
|
import re
|
||||||
|
import time
|
||||||
|
|
||||||
|
# Absolutos, como el resto del nucleo: jarvis.py mete su carpeta en sys.path y
|
||||||
|
# todos los paquetes son de primer nivel. Con `..manos` esto solo se podria
|
||||||
|
# importar desde fuera, y las pruebas lo cargan suelto.
|
||||||
|
from manos.acciones import normaliza
|
||||||
|
from manos.fonetica import fonetica
|
||||||
|
|
||||||
|
NOMBRE = "jarvis"
|
||||||
|
|
||||||
|
# Cuanto sigue escuchando tras oir su nombre. Corto obliga a repetirlo en cada
|
||||||
|
# frase; largo devuelve al problema de origen, que obedezca a la tele.
|
||||||
|
DESPIERTO_S = 25.0
|
||||||
|
|
||||||
|
# Lo que Whisper escribe cuando oye "JARVIS". Salen del registro real de uso,
|
||||||
|
# no de imaginarlas.
|
||||||
|
PARECIDAS = (
|
||||||
|
"jarvis", "yarvis", "charvis", "jarbis", "yarbis", "harvis", "jervis",
|
||||||
|
"jarvi", "yarvi", "javis", "jarves", "charles", "chavez", "harvest",
|
||||||
|
"jarvix", "sharvis", "arvis",
|
||||||
|
)
|
||||||
|
|
||||||
|
# Se compara palabra a palabra, asi que el umbral puede ser alto sin perder
|
||||||
|
# aciertos: "yarvis" contra "jarvis" da 0,83 por letra y sube por sonido.
|
||||||
|
UMBRAL = 0.80
|
||||||
|
|
||||||
|
_LIMPIA = re.compile(r"^[\s,.:;¡!¿?]+|[\s,.:;¡!¿?]+$")
|
||||||
|
|
||||||
|
# Lo que suele acompañar al nombre sin ser una orden. Si al quitar el nombre
|
||||||
|
# solo queda esto, es que llamaron y ya: "oye jarvis" no es "haz oye".
|
||||||
|
LLAMADAS = {"oye", "eh", "hey", "ey", "hola", "escucha", "atiende", "perdona",
|
||||||
|
"por favor", "porfa", "venga", "a ver"}
|
||||||
|
|
||||||
|
|
||||||
|
def _suena_al_nombre(palabra: str) -> bool:
|
||||||
|
p = _LIMPIA.sub("", palabra)
|
||||||
|
if len(p) < 4:
|
||||||
|
return False
|
||||||
|
if p in PARECIDAS:
|
||||||
|
return True
|
||||||
|
for candidata in (NOMBRE,) + PARECIDAS[:6]:
|
||||||
|
if difflib.SequenceMatcher(None, p, candidata).ratio() >= UMBRAL:
|
||||||
|
return True
|
||||||
|
if difflib.SequenceMatcher(None, fonetica(p), fonetica(candidata)).ratio() >= UMBRAL:
|
||||||
|
return True
|
||||||
|
return False
|
||||||
|
|
||||||
|
|
||||||
|
def parte_el_nombre(texto: str):
|
||||||
|
"""(lo llamaron, lo que queda de la frase sin el nombre).
|
||||||
|
|
||||||
|
Se devuelve el resto porque "JARVIS, cuanto espacio queda" tiene que
|
||||||
|
ejecutarse en la misma frase: obligar a decir el nombre y luego la orden
|
||||||
|
aparte es exactamente lo que hace que un asistente canse.
|
||||||
|
"""
|
||||||
|
palabras = normaliza(texto).split()
|
||||||
|
if not palabras:
|
||||||
|
return False, ""
|
||||||
|
for i, p in enumerate(palabras):
|
||||||
|
if _suena_al_nombre(p):
|
||||||
|
sobra = [q for q in palabras[:i] + palabras[i + 1:]
|
||||||
|
if q not in LLAMADAS]
|
||||||
|
return True, " ".join(sobra).strip()
|
||||||
|
return False, ""
|
||||||
|
|
||||||
|
|
||||||
|
class Centinela:
|
||||||
|
"""Decide si una frase hay que atenderla o dejarla pasar."""
|
||||||
|
|
||||||
|
def __init__(self, activo=True, ventana=DESPIERTO_S):
|
||||||
|
self.activo = activo
|
||||||
|
self.ventana = ventana
|
||||||
|
self._hasta = 0.0
|
||||||
|
|
||||||
|
@property
|
||||||
|
def despierto(self) -> bool:
|
||||||
|
return not self.activo or time.monotonic() < self._hasta
|
||||||
|
|
||||||
|
def despierta(self):
|
||||||
|
self._hasta = time.monotonic() + self.ventana
|
||||||
|
|
||||||
|
def duerme(self):
|
||||||
|
self._hasta = 0.0
|
||||||
|
|
||||||
|
def filtra(self, texto: str):
|
||||||
|
"""(hay que atenderla, texto a atender, acaba de despertar).
|
||||||
|
|
||||||
|
- Sin palabra de activacion configurada: se atiende todo.
|
||||||
|
- Dormido y sin nombre: se ignora.
|
||||||
|
- Dormido y con nombre: despierta. Si la frase traia ademas la orden,
|
||||||
|
se devuelve; si solo traia el nombre, se contesta con un acuse.
|
||||||
|
- Despierto: se atiende y se renueva la ventana, para poder encadenar.
|
||||||
|
"""
|
||||||
|
if not self.activo:
|
||||||
|
return True, texto, False
|
||||||
|
|
||||||
|
llamado, resto = parte_el_nombre(texto)
|
||||||
|
|
||||||
|
if llamado:
|
||||||
|
recien = not self.despierto
|
||||||
|
self.despierta()
|
||||||
|
return (True, resto, recien) if resto else (False, "", recien)
|
||||||
|
|
||||||
|
if self.despierto:
|
||||||
|
self.despierta() # encadenar sin repetir el nombre
|
||||||
|
return True, texto, False
|
||||||
|
|
||||||
|
return False, "", False
|
||||||
343
nucleo/oido/whisper.py
Normal file
343
nucleo/oido/whisper.py
Normal file
|
|
@ -0,0 +1,343 @@
|
||||||
|
"""Transcribir: arrancar whisper-server y mandarle los WAV.
|
||||||
|
|
||||||
|
Newelle dedicaba 804 lineas a esto porque tenia que descargar modelos, elegir
|
||||||
|
entre CLI y servidor, salir del sandbox y ofrecerlo todo en una pantalla de
|
||||||
|
ajustes. Nosotros ya tenemos el binario compilado con CUDA y el modelo en el
|
||||||
|
disco: queda arrancar un proceso y hacer un POST.
|
||||||
|
|
||||||
|
## Los cuatro flags que Newelle no pasaba
|
||||||
|
|
||||||
|
Esto es lo importante de este fichero, y sale de leer el codigo de upstream:
|
||||||
|
`whispercpp_handler.py` arranca el servidor con `-m -t --host --port -l` y nada
|
||||||
|
mas. Los defectos de `whisper-server` no son los mismos que los de
|
||||||
|
`whisper-cli`, asi que se estaba transcribiendo peor de lo que la propia
|
||||||
|
whisper.cpp hace por defecto:
|
||||||
|
|
||||||
|
--beam-size 5 --best-of 5 whisper-server trae beam-size -1, que es
|
||||||
|
decodificacion GREEDY. El CLI usa 5. Es la causa
|
||||||
|
mas probable de transcripciones como "esta con el
|
||||||
|
tanutusto" en un audio limpio.
|
||||||
|
-sns suprime los tokens que no son habla. Es
|
||||||
|
literalmente el flag que evita los "[Musica]" y
|
||||||
|
"(aplausos)", que son el 16,2 % de las frases que
|
||||||
|
JARVIS no entendio.
|
||||||
|
--prompt + --carry-initial-prompt
|
||||||
|
vocabulario del dominio. MEDIDO Y DESCARTADO por
|
||||||
|
defecto: ver abajo.
|
||||||
|
|
||||||
|
El prompt se genera DESDE el catalogo (`prompt_dominio`), no escrito a mano, o
|
||||||
|
se queda viejo en cuanto se añada una accion.
|
||||||
|
|
||||||
|
## Lo que dijo la medida, que no fue lo que yo esperaba
|
||||||
|
|
||||||
|
40 frases del catalogo dichas por Piper con tres voces, transcritas con cada
|
||||||
|
configuracion y contando cuantas llegan a su accion:
|
||||||
|
|
||||||
|
como lo hace Newelle (greedy, sin sns) 50,0 % 0,98 s
|
||||||
|
+ beam 5 55,0 % 1,01 s
|
||||||
|
+ beam 5 + sns 55,0 % 1,01 s
|
||||||
|
+ beam 5 + sns + prompt 52,5 % 1,12 s
|
||||||
|
|
||||||
|
Tres lecturas, por orden de importancia:
|
||||||
|
|
||||||
|
1. **El prompt EMPEORA.** Era el riesgo anotado —Whisper empieza a "oir" las
|
||||||
|
palabras que le has puesto donde no las hay— y se cumplio. Va apagado por
|
||||||
|
defecto; se deja el codigo porque con un prompt mas corto podria ganar, pero
|
||||||
|
hay que demostrarlo antes de encenderlo.
|
||||||
|
2. **`-sns` no se puede medir con este banco.** El audio de Piper no tiene
|
||||||
|
silencios ni musica, asi que no hay nada que suprimir. Se deja puesto porque
|
||||||
|
no cuesta nada y ataca un problema real que solo se ve con microfono: el
|
||||||
|
16,2 % de "[Musica]" del registro de uso.
|
||||||
|
3. **El beam sube 5 puntos y cuesta 30 ms.** Es lo unico claramente a favor, y
|
||||||
|
aun asi con 40 muestras esos 5 puntos son dos frases: esta en el limite del
|
||||||
|
ruido.
|
||||||
|
"""
|
||||||
|
import atexit
|
||||||
|
import json
|
||||||
|
import os
|
||||||
|
import re
|
||||||
|
import signal
|
||||||
|
import socket
|
||||||
|
import subprocess
|
||||||
|
import time
|
||||||
|
import urllib.error
|
||||||
|
import urllib.request
|
||||||
|
|
||||||
|
RAIZ = os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
|
||||||
|
BINARIO = os.path.join(RAIZ, "voz", "whisper-cuda", "whisper.cpp", "build", "bin",
|
||||||
|
"whisper-server")
|
||||||
|
MODELOS = os.path.expanduser(
|
||||||
|
"~/.var/app/io.github.qwersyk.Newelle/config/models/whisper/whisper.cpp/models")
|
||||||
|
|
||||||
|
# Las libs de ggml estan al lado del binario y CUDA en /usr/local. Fuera del
|
||||||
|
# flatpak esto es una linea; dentro era media pagina de flatpak-spawn.
|
||||||
|
LIBS = "/usr/local/cuda/lib64"
|
||||||
|
|
||||||
|
# Un prompt largo no ayuda: Whisper empieza a "oir" esas palabras donde no las
|
||||||
|
# hay. Se corta.
|
||||||
|
TOPE_PROMPT = 220
|
||||||
|
|
||||||
|
# El prompt MINIMO, y el unico que va puesto por defecto: solo el nombre.
|
||||||
|
#
|
||||||
|
# Sin el, Whisper no escribe "JARVIS" nunca: se lo come y lo sustituye por la
|
||||||
|
# palabra española que mejor le cuadre acusticamente. Medido diciendoselo con
|
||||||
|
# Piper:
|
||||||
|
#
|
||||||
|
# "Jarvis, cuanto espacio queda" -> "¿Sabeis cuanto espacio queda?"
|
||||||
|
# "Yarvis, que hora es" -> "¿Ya viste que hora es?"
|
||||||
|
# "Jarvis pon musica" -> "Carbis Pond Musica."
|
||||||
|
#
|
||||||
|
# Y ninguna de esas se parece al nombre ni por letra ni por sonido, asi que el
|
||||||
|
# centinela no despertaba JAMAS. Era la causa de que el asistente no contestara.
|
||||||
|
#
|
||||||
|
# Con este prompt de cinco palabras, cuatro de cuatro. Y ojo al matiz, porque
|
||||||
|
# contradice lo de arriba solo en apariencia: lo que empeora es el prompt LARGO
|
||||||
|
# con todo el vocabulario del catalogo. Este cuesta una frase de ochenta —90,0 a
|
||||||
|
# 88,8 % de acierto general, dentro del ruido— y arregla el nombre entero.
|
||||||
|
PROMPT_NOMBRE = "JARVIS. Hablando con JARVIS."
|
||||||
|
|
||||||
|
|
||||||
|
def prompt_dominio(catalogo=None) -> str:
|
||||||
|
"""Vocabulario que JARVIS espera oir, sacado del catalogo.
|
||||||
|
|
||||||
|
Se cogen las palabras poco comunes —las que un modelo de castellano general
|
||||||
|
no espera— y no las frases enteras: el prompt es un sesgo, no una lista de
|
||||||
|
ordenes, y llenarlo de "cuanto espacio queda" haria que las oyera en
|
||||||
|
cualquier ruido.
|
||||||
|
"""
|
||||||
|
comunes = {
|
||||||
|
"abre", "cierra", "busca", "pon", "quita", "sube", "baja", "dime",
|
||||||
|
"cuanto", "cuanta", "cuantos", "que", "el", "la", "los", "las", "de",
|
||||||
|
"del", "en", "con", "por", "para", "un", "una", "y", "o", "a", "al",
|
||||||
|
"me", "se", "lo", "es", "esta", "hay", "mi", "tu", "su",
|
||||||
|
}
|
||||||
|
# Por grupos y en rueda, no por orden del catalogo. Recorriendolo en orden,
|
||||||
|
# el tope de caracteres se lo comian entero las acciones de disco —que van
|
||||||
|
# primeras— y no llegaba ni una palabra de firefox, ventanas o pentest.
|
||||||
|
por_grupo, vistas = {}, set()
|
||||||
|
for a in (catalogo.acciones if catalogo else []):
|
||||||
|
for frase in a.frases:
|
||||||
|
for p in frase.split():
|
||||||
|
if len(p) < 4 or p in comunes or p in vistas:
|
||||||
|
continue
|
||||||
|
vistas.add(p)
|
||||||
|
por_grupo.setdefault(a.grupo or "otras", []).append(p)
|
||||||
|
|
||||||
|
palabras = []
|
||||||
|
grupos = list(por_grupo.values())
|
||||||
|
for i in range(max((len(g) for g in grupos), default=0)):
|
||||||
|
for g in grupos:
|
||||||
|
if i < len(g):
|
||||||
|
palabras.append(g[i])
|
||||||
|
# Los nombres propios importan mas que nada y no salen del catalogo tal cual
|
||||||
|
fijas = ["JARVIS", "firefox", "nmap", "ollama", "whisper", "terminal",
|
||||||
|
"escritorio", "pantalla", "wifi", "bluetooth", "github", "youtube"]
|
||||||
|
texto = ", ".join(fijas + palabras)
|
||||||
|
return texto[:TOPE_PROMPT].rsplit(",", 1)[0]
|
||||||
|
|
||||||
|
|
||||||
|
def _mata_huerfanos():
|
||||||
|
"""whisper-server de arranques anteriores que se quedaron con la grafica.
|
||||||
|
|
||||||
|
Se buscan por la RUTA COMPLETA del binario, no por el nombre: `pkill -f
|
||||||
|
whisper` casaria con el propio pkill y con cualquier cosa que lleve la
|
||||||
|
palabra, y eso ya ha costado depuraciones. Y se leen los cmdline de /proc en
|
||||||
|
vez de llamar a pgrep, que es lo mismo pero sin proceso de por medio.
|
||||||
|
"""
|
||||||
|
yo = os.getpid()
|
||||||
|
for pid in os.listdir("/proc"):
|
||||||
|
if not pid.isdigit() or int(pid) == yo:
|
||||||
|
continue
|
||||||
|
try:
|
||||||
|
with open(f"/proc/{pid}/cmdline", "rb") as f:
|
||||||
|
orden = f.read().split(b"\0")
|
||||||
|
except OSError:
|
||||||
|
continue
|
||||||
|
if orden and orden[0].decode(errors="ignore") == BINARIO:
|
||||||
|
try:
|
||||||
|
os.killpg(os.getpgid(int(pid)), signal.SIGTERM)
|
||||||
|
except (OSError, ProcessLookupError):
|
||||||
|
pass
|
||||||
|
|
||||||
|
|
||||||
|
def _puerto_libre() -> int:
|
||||||
|
with socket.socket() as s:
|
||||||
|
s.bind(("127.0.0.1", 0))
|
||||||
|
return s.getsockname()[1]
|
||||||
|
|
||||||
|
|
||||||
|
class Oido:
|
||||||
|
"""whisper-server vivo, y un metodo para transcribir un WAV."""
|
||||||
|
|
||||||
|
def __init__(self, modelo="small", idioma="es", hilos=8, prompt=PROMPT_NOMBRE,
|
||||||
|
beam=5, gpu=True):
|
||||||
|
self.modelo = modelo
|
||||||
|
self.idioma = idioma
|
||||||
|
self.hilos = hilos
|
||||||
|
self.prompt = prompt
|
||||||
|
self.beam = beam
|
||||||
|
self.gpu = gpu
|
||||||
|
self._proc = None
|
||||||
|
self._puerto = None
|
||||||
|
|
||||||
|
@property
|
||||||
|
def ruta_modelo(self) -> str:
|
||||||
|
return os.path.join(MODELOS, f"ggml-{self.modelo}.bin")
|
||||||
|
|
||||||
|
def disponible(self) -> bool:
|
||||||
|
return os.path.exists(BINARIO) and os.path.exists(self.ruta_modelo)
|
||||||
|
|
||||||
|
# ------------------------------------------------------------- arrancar
|
||||||
|
|
||||||
|
def arranca(self, espera=40) -> bool:
|
||||||
|
if self._proc and self._proc.poll() is None:
|
||||||
|
return True
|
||||||
|
if not self.disponible():
|
||||||
|
return False
|
||||||
|
|
||||||
|
# Los huerfanos de arranques anteriores, antes de nada.
|
||||||
|
#
|
||||||
|
# whisper-server se lanza en su propio grupo de procesos para poder
|
||||||
|
# matarlo entero, pero eso mismo hace que sobreviva si el nucleo muere
|
||||||
|
# de golpe (un kill, un cuelgue, cerrar la terminal). Y cada uno se
|
||||||
|
# queda con ~880 MiB de una tarjeta de 4 GB: al cuarto, el siguiente ya
|
||||||
|
# no arranca y el sintoma es "whisper no arranco", que no apunta a
|
||||||
|
# ningun sitio. Medido en esta maquina: cuatro huerfanos, 3,5 GB.
|
||||||
|
_mata_huerfanos()
|
||||||
|
|
||||||
|
self._puerto = _puerto_libre()
|
||||||
|
orden = [
|
||||||
|
BINARIO,
|
||||||
|
"-m", self.ruta_modelo,
|
||||||
|
"-t", str(self.hilos),
|
||||||
|
"--host", "127.0.0.1",
|
||||||
|
"--port", str(self._puerto),
|
||||||
|
"-l", self.idioma,
|
||||||
|
# los cuatro que Newelle no pasaba
|
||||||
|
"-sns",
|
||||||
|
"--beam-size", str(self.beam),
|
||||||
|
"--best-of", "5",
|
||||||
|
]
|
||||||
|
if self.prompt:
|
||||||
|
orden += ["--prompt", self.prompt, "--carry-initial-prompt"]
|
||||||
|
if not self.gpu:
|
||||||
|
orden.append("--no-gpu")
|
||||||
|
|
||||||
|
entorno = {**os.environ,
|
||||||
|
"LD_LIBRARY_PATH": LIBS + ":" + os.environ.get("LD_LIBRARY_PATH", "")}
|
||||||
|
self._proc = subprocess.Popen(
|
||||||
|
orden, env=entorno, cwd=os.path.dirname(BINARIO),
|
||||||
|
stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL,
|
||||||
|
# grupo propio, para poder matarlo entero como hace tareas.py
|
||||||
|
start_new_session=True)
|
||||||
|
# Y que se vaya con nosotros: sin esto se queda con su parte de la
|
||||||
|
# grafica hasta el siguiente reinicio.
|
||||||
|
atexit.register(self.para)
|
||||||
|
|
||||||
|
# Esperar a que escuche de verdad, no a que el proceso exista: cargar
|
||||||
|
# el modelo en la grafica tarda, y un POST antes de tiempo da un error
|
||||||
|
# de conexion que parece un fallo de configuracion.
|
||||||
|
limite = time.monotonic() + espera
|
||||||
|
while time.monotonic() < limite:
|
||||||
|
if self._proc.poll() is not None:
|
||||||
|
return False
|
||||||
|
try:
|
||||||
|
with socket.create_connection(("127.0.0.1", self._puerto), 0.5):
|
||||||
|
return True
|
||||||
|
except OSError:
|
||||||
|
time.sleep(0.3)
|
||||||
|
self.para()
|
||||||
|
return False
|
||||||
|
|
||||||
|
def para(self):
|
||||||
|
if not self._proc:
|
||||||
|
return
|
||||||
|
try:
|
||||||
|
os.killpg(os.getpgid(self._proc.pid), signal.SIGTERM)
|
||||||
|
self._proc.wait(timeout=5)
|
||||||
|
except Exception:
|
||||||
|
try:
|
||||||
|
os.killpg(os.getpgid(self._proc.pid), signal.SIGKILL)
|
||||||
|
except Exception:
|
||||||
|
pass
|
||||||
|
self._proc = None
|
||||||
|
|
||||||
|
@property
|
||||||
|
def vivo(self) -> bool:
|
||||||
|
return bool(self._proc and self._proc.poll() is None)
|
||||||
|
|
||||||
|
# ---------------------------------------------------------- transcribir
|
||||||
|
|
||||||
|
def transcribe(self, wav: str) -> str:
|
||||||
|
if not self.vivo and not self.arranca():
|
||||||
|
return ""
|
||||||
|
try:
|
||||||
|
with open(wav, "rb") as f:
|
||||||
|
datos = f.read()
|
||||||
|
except OSError:
|
||||||
|
return ""
|
||||||
|
|
||||||
|
lim = "----jarvis"
|
||||||
|
cuerpo = (
|
||||||
|
f"--{lim}\r\n"
|
||||||
|
f'Content-Disposition: form-data; name="file"; filename="a.wav"\r\n'
|
||||||
|
f"Content-Type: audio/wav\r\n\r\n"
|
||||||
|
).encode() + datos + f"\r\n--{lim}--\r\n".encode()
|
||||||
|
|
||||||
|
req = urllib.request.Request(
|
||||||
|
f"http://127.0.0.1:{self._puerto}/inference", data=cuerpo,
|
||||||
|
headers={"Content-Type": f"multipart/form-data; boundary={lim}"})
|
||||||
|
try:
|
||||||
|
with urllib.request.urlopen(req, timeout=120) as r:
|
||||||
|
return json.loads(r.read().decode()).get("text", "").strip()
|
||||||
|
except (urllib.error.URLError, json.JSONDecodeError, OSError):
|
||||||
|
return ""
|
||||||
|
|
||||||
|
|
||||||
|
# --------------------------------------------------------------- el filtro
|
||||||
|
|
||||||
|
# Lo que Whisper devuelve cuando no habia nadie hablando. No es un fallo suyo:
|
||||||
|
# se entreno con subtitulos de YouTube, donde el silencio se anota asi.
|
||||||
|
SOLO_ETIQUETA = re.compile(r"^\s*[\[\(\*].{0,40}[\]\)\*]\s*[.!¡]*\s*$")
|
||||||
|
MULETILLAS = (
|
||||||
|
"suscribete", "suscríbete", "gracias por ver", "hasta la proxima",
|
||||||
|
"hasta la próxima", "no olvides suscribirte", "dale like",
|
||||||
|
)
|
||||||
|
|
||||||
|
# Anotaciones que Whisper escribe cuando no hay nadie hablando. Salen de contar
|
||||||
|
# el registro real de JARVIS, no de imaginarlas: son las que mas se repiten
|
||||||
|
# entre las frases cortas que no llegan a ninguna accion.
|
||||||
|
#
|
||||||
|
# A veces vienen entre corchetes —y entonces las coge SOLO_ETIQUETA— y a veces
|
||||||
|
# sueltas, que es para lo que sirve esta lista.
|
||||||
|
ANOTACIONES = {
|
||||||
|
"musica", "música", "motor", "risas", "risa", "aplausos", "cantando",
|
||||||
|
"ruido", "silencio", "tos", "suspiro", "aplauso", "llanto", "gritos",
|
||||||
|
"ah", "ahh", "ahhh", "eh", "ehh", "mmm", "hmm", "uf", "ay",
|
||||||
|
}
|
||||||
|
|
||||||
|
# Lo que SI se deja pasar aunque no lleve a ninguna accion: "hola", "adios",
|
||||||
|
# "gracias", "buenas". Una persona las dice de verdad y merecen respuesta; lo
|
||||||
|
# unico que cuesta dejarlas pasar es una consulta al modelo. Filtrar de mas
|
||||||
|
# aqui es peor que filtrar de menos: JARVIS parecería sordo a un saludo.
|
||||||
|
|
||||||
|
|
||||||
|
def es_ruido(texto: str) -> bool:
|
||||||
|
"""Si esto es Whisper alucinando en vez de alguien hablando.
|
||||||
|
|
||||||
|
Se aplica ANTES del emparejador y antes de anotar el fallo. Sin esto, el
|
||||||
|
16,2 % del registro de "no entendido" son "[Musica]" y "(aplausos)", y la
|
||||||
|
mejora nocturna acaba generando alias a partir de ellos.
|
||||||
|
|
||||||
|
Conservador a proposito. Lo que se cuela solo cuesta una consulta al modelo;
|
||||||
|
lo que se filtra de mas es una orden que JARVIS ignora, y eso se vive como
|
||||||
|
que no funciona.
|
||||||
|
"""
|
||||||
|
if not texto or not texto.strip():
|
||||||
|
return True
|
||||||
|
if SOLO_ETIQUETA.match(texto):
|
||||||
|
return True
|
||||||
|
limpio = texto.lower().strip(" .,!¡?¿*-—")
|
||||||
|
if limpio in ANOTACIONES:
|
||||||
|
return True
|
||||||
|
return any(m in limpio for m in MULETILLAS)
|
||||||
169
nucleo/pruebas/banco.py
Executable file
169
nucleo/pruebas/banco.py
Executable file
|
|
@ -0,0 +1,169 @@
|
||||||
|
#!/usr/bin/env python3
|
||||||
|
"""Banco fijo para medir el emparejador sin volver a grabar.
|
||||||
|
|
||||||
|
banco.py --crear [n] graba y transcribe una vez (lento)
|
||||||
|
banco.py --mide puntua el catalogo actual (instantaneo)
|
||||||
|
banco.py --fallos enseña que se sigue fallando
|
||||||
|
|
||||||
|
## Por que hace falta
|
||||||
|
|
||||||
|
La mejora nocturna medía generando audio nuevo cada ronda: nueve horas, 39
|
||||||
|
rondas, +1,45 puntos de mejora contra ±1,9 puntos de ruido de medida. El ruido
|
||||||
|
era mayor que la mejora, asi que "¿esto mejora o empeora?" se decidia a cara o
|
||||||
|
cruz. Hoy ha vuelto a pasar: los flags de Whisper parecian dar +5 puntos con 40
|
||||||
|
muestras y con 150 no dan nada.
|
||||||
|
|
||||||
|
Aqui se graba UNA vez con semilla fija y se guardan las TRANSCRIPCIONES. A
|
||||||
|
partir de ahi, probar un cambio en el emparejador es instantaneo y determinista:
|
||||||
|
la misma entrada siempre, asi que dos medidas son comparables de verdad.
|
||||||
|
|
||||||
|
## La trampa que ya costo una conclusion equivocada
|
||||||
|
|
||||||
|
El 24 % del catalogo son acciones que piden argumento. Diciendolas sueltas
|
||||||
|
—"busca el texto"— el emparejador NO las dispara, y hace bien: no son una orden.
|
||||||
|
Un banco que las dice sueltas mide 56 % donde la realidad es 79 %, y hace
|
||||||
|
parecer que el emparejador esta roto cuando lo que esta roto es el banco.
|
||||||
|
Por eso `--crear` les añade argumento.
|
||||||
|
"""
|
||||||
|
import argparse
|
||||||
|
import collections
|
||||||
|
import difflib
|
||||||
|
import json
|
||||||
|
import os
|
||||||
|
import random
|
||||||
|
import subprocess
|
||||||
|
import sys
|
||||||
|
import tempfile
|
||||||
|
|
||||||
|
AQUI = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
|
||||||
|
sys.path.insert(0, AQUI)
|
||||||
|
|
||||||
|
from manos.acciones import Catalogo, normaliza # noqa: E402
|
||||||
|
from oido.whisper import Oido, es_ruido # noqa: E402
|
||||||
|
|
||||||
|
RAIZ = os.path.dirname(AQUI)
|
||||||
|
PIPER = os.path.join(RAIZ, "config", "jarvis-piper.sh")
|
||||||
|
CATALOGO = os.path.join(AQUI, "datos", "acciones.json")
|
||||||
|
BANCO = os.path.join(AQUI, "datos", "banco.json")
|
||||||
|
|
||||||
|
# Fijas a proposito: son lo que hace el banco reproducible. Cambiarlas obliga a
|
||||||
|
# rehacerlo, y esa es justamente la señal de que ya no es comparable.
|
||||||
|
VOCES = ["es_ES-davefx-medium", "es_MX-claude-high", "es_ES-sharvard-medium"]
|
||||||
|
SEMILLA = 20260815
|
||||||
|
ARGUMENTOS = ["informes", "descargas", "musica", "el proyecto", "documentos"]
|
||||||
|
|
||||||
|
|
||||||
|
def crear(n: int) -> int:
|
||||||
|
cat = Catalogo([CATALOGO])
|
||||||
|
rnd = random.Random(SEMILLA)
|
||||||
|
conf = [a for a in cat.acciones if a.frases]
|
||||||
|
|
||||||
|
casos = []
|
||||||
|
for a in rnd.sample(conf, min(n, len(conf))):
|
||||||
|
frase = rnd.choice(a.frases)
|
||||||
|
if a.captura:
|
||||||
|
frase += " " + rnd.choice(ARGUMENTOS)
|
||||||
|
casos.append({"id": a.id, "frase": frase, "voz": rnd.choice(VOCES),
|
||||||
|
"captura": a.captura})
|
||||||
|
|
||||||
|
print(f" grabando {len(casos)} frases...", flush=True)
|
||||||
|
tmp = tempfile.mkdtemp(prefix="banco")
|
||||||
|
for i, c in enumerate(casos):
|
||||||
|
wav = os.path.join(tmp, f"{i:03d}.wav")
|
||||||
|
subprocess.run([PIPER, wav, c["frase"]],
|
||||||
|
env={**os.environ, "JARVIS_PIPER_VOZ": c["voz"],
|
||||||
|
"JARVIS_PIPER_TONO": "1.0"},
|
||||||
|
capture_output=True, timeout=90)
|
||||||
|
c["wav"] = wav if os.path.exists(wav) and os.path.getsize(wav) else None
|
||||||
|
|
||||||
|
oreja = Oido(modelo="small", beam=5)
|
||||||
|
if not oreja.arranca():
|
||||||
|
print(" whisper no arranco")
|
||||||
|
return 2
|
||||||
|
print(" transcribiendo...", flush=True)
|
||||||
|
for i, c in enumerate(casos):
|
||||||
|
c["oido"] = oreja.transcribe(c["wav"]) if c["wav"] else ""
|
||||||
|
c.pop("wav", None)
|
||||||
|
if (i + 1) % 40 == 0:
|
||||||
|
print(f" {i+1}/{len(casos)}", flush=True)
|
||||||
|
oreja.para()
|
||||||
|
subprocess.run(["rm", "-rf", tmp])
|
||||||
|
|
||||||
|
casos = [c for c in casos if c.get("oido")]
|
||||||
|
os.makedirs(os.path.dirname(BANCO), exist_ok=True)
|
||||||
|
with open(BANCO, "w", encoding="utf-8") as f:
|
||||||
|
json.dump({"semilla": SEMILLA, "modelo": "small", "casos": casos},
|
||||||
|
f, ensure_ascii=False, indent=1)
|
||||||
|
print(f" guardado: {len(casos)} transcripciones en {BANCO}")
|
||||||
|
return 0
|
||||||
|
|
||||||
|
|
||||||
|
def carga():
|
||||||
|
try:
|
||||||
|
with open(BANCO, encoding="utf-8") as f:
|
||||||
|
return json.load(f)["casos"]
|
||||||
|
except (OSError, json.JSONDecodeError, KeyError):
|
||||||
|
return []
|
||||||
|
|
||||||
|
|
||||||
|
def mide(detalle=False) -> int:
|
||||||
|
casos = carga()
|
||||||
|
if not casos:
|
||||||
|
print(" no hay banco: crealo con --crear")
|
||||||
|
return 1
|
||||||
|
cat = Catalogo([CATALOGO])
|
||||||
|
|
||||||
|
bien = 0
|
||||||
|
oye_mal, no_relaciona, otra, ruido = [], [], [], []
|
||||||
|
for c in casos:
|
||||||
|
t = c["oido"]
|
||||||
|
if es_ruido(t):
|
||||||
|
ruido.append(c)
|
||||||
|
continue
|
||||||
|
a, _ = cat.busca(t)
|
||||||
|
if a is not None and a.id == c["id"]:
|
||||||
|
bien += 1
|
||||||
|
continue
|
||||||
|
p = difflib.SequenceMatcher(None, normaliza(t), normaliza(c["frase"])).ratio()
|
||||||
|
if p < 0.75:
|
||||||
|
oye_mal.append((c, t, p))
|
||||||
|
elif a is None:
|
||||||
|
no_relaciona.append((c, t, p))
|
||||||
|
else:
|
||||||
|
otra.append((c, t, a.id))
|
||||||
|
|
||||||
|
n = len(casos)
|
||||||
|
print(f" {n} frases · acierto {100*bien/n:.1f} %\n")
|
||||||
|
print(f" {'que pasa':28s} {'n':>4s} {'%':>7s}")
|
||||||
|
print(" " + "-" * 44)
|
||||||
|
for nombre, k in [("bien", bien), ("oye bien, NO RELACIONA", len(no_relaciona)),
|
||||||
|
("OYE MAL la frase", len(oye_mal)),
|
||||||
|
("oye bien, OTRA accion", len(otra)),
|
||||||
|
("lo tira por ruido", len(ruido))]:
|
||||||
|
print(f" {nombre:28s} {k:4d} {100*k/n:6.1f} %")
|
||||||
|
|
||||||
|
if detalle:
|
||||||
|
print("\n --- oye bien pero no relaciona ---")
|
||||||
|
for c, t, p in no_relaciona:
|
||||||
|
print(f" {c['id']:24s} dijo: {c['frase']}")
|
||||||
|
print(f" {'':24s} oyo: {t} ({p:.2f})")
|
||||||
|
print("\n --- se la lleva otra accion (lo peor: ejecuta lo que no es) ---")
|
||||||
|
for c, t, o in otra:
|
||||||
|
print(f" {c['id']:24s} -> {o} oyo: {t}")
|
||||||
|
return 0
|
||||||
|
|
||||||
|
|
||||||
|
def main() -> int:
|
||||||
|
p = argparse.ArgumentParser()
|
||||||
|
p.add_argument("--crear", action="store_true")
|
||||||
|
p.add_argument("--mide", action="store_true")
|
||||||
|
p.add_argument("--fallos", action="store_true")
|
||||||
|
p.add_argument("n", nargs="?", type=int, default=150)
|
||||||
|
a = p.parse_args()
|
||||||
|
if a.crear:
|
||||||
|
return crear(a.n)
|
||||||
|
return mide(detalle=a.fallos)
|
||||||
|
|
||||||
|
|
||||||
|
if __name__ == "__main__":
|
||||||
|
sys.exit(main())
|
||||||
133
nucleo/pruebas/prueba_candado.py
Executable file
133
nucleo/pruebas/prueba_candado.py
Executable file
|
|
@ -0,0 +1,133 @@
|
||||||
|
#!/usr/bin/env python3
|
||||||
|
"""El candado: que tape, que rechace lo que no es, y que NO obedezca.
|
||||||
|
|
||||||
|
./venv/bin/python pruebas/prueba_candado.py
|
||||||
|
|
||||||
|
Lo que de verdad importa aqui no es que el panel se ponga negro —eso es
|
||||||
|
cosmetica— sino que con el candado puesto **no se ejecute nada**. El panel tapado
|
||||||
|
pero obedeciendo seria peor que no tener candado, porque da sensacion de
|
||||||
|
seguridad sin darla.
|
||||||
|
|
||||||
|
No se prueba con la contraseña de verdad: no la tenemos ni hace falta. Se
|
||||||
|
comprueba que una mala se rechaza y que mientras tanto no pasa ni una orden.
|
||||||
|
"""
|
||||||
|
import os
|
||||||
|
import sys
|
||||||
|
import threading
|
||||||
|
import time
|
||||||
|
|
||||||
|
AQUI = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
|
||||||
|
sys.path.insert(0, AQUI)
|
||||||
|
|
||||||
|
from boca.voz import Boca # noqa: E402
|
||||||
|
from cara.panel import Panel # noqa: E402
|
||||||
|
from manos import Manos # noqa: E402
|
||||||
|
|
||||||
|
fallos = []
|
||||||
|
|
||||||
|
|
||||||
|
def afirma(condicion, queja):
|
||||||
|
print(f" {'OK ' if condicion else 'MAL'} {queja}")
|
||||||
|
if not condicion:
|
||||||
|
fallos.append(queja)
|
||||||
|
|
||||||
|
|
||||||
|
class CaraFalsa:
|
||||||
|
"""Se queda con lo que el panel manda, sin levantar ningun servidor."""
|
||||||
|
|
||||||
|
def __init__(self):
|
||||||
|
self.mensajes = []
|
||||||
|
self.conectados = 1
|
||||||
|
|
||||||
|
def manda(self, tipo, datos):
|
||||||
|
self.mensajes.append((tipo, datos))
|
||||||
|
|
||||||
|
def de(self, tipo):
|
||||||
|
return [d for t, d in self.mensajes if t == tipo]
|
||||||
|
|
||||||
|
|
||||||
|
class BocaMuda(Boca):
|
||||||
|
"""Como la de verdad pero sin sonar: la prueba no tiene que hablar."""
|
||||||
|
|
||||||
|
def __init__(self):
|
||||||
|
super().__init__("davefx")
|
||||||
|
self.dicho = []
|
||||||
|
|
||||||
|
def di(self, texto):
|
||||||
|
self.dicho.append(texto); return True
|
||||||
|
|
||||||
|
def di_si_libre(self, texto):
|
||||||
|
self.dicho.append(texto); return True
|
||||||
|
|
||||||
|
|
||||||
|
def main() -> int:
|
||||||
|
manos = Manos()
|
||||||
|
cara = CaraFalsa()
|
||||||
|
boca = BocaMuda()
|
||||||
|
p = Panel(cara, boca, manos, candado=True)
|
||||||
|
|
||||||
|
print("\n al abrir")
|
||||||
|
p.arranca()
|
||||||
|
time.sleep(0.2)
|
||||||
|
afirma(not p.desbloqueado, "nace bloqueado")
|
||||||
|
afirma(bool(cara.de("bloqueo")), "pide la contraseña nada mas abrir")
|
||||||
|
|
||||||
|
print("\n con el candado puesto NO obedece")
|
||||||
|
antes = len(cara.mensajes)
|
||||||
|
for orden in ("prueba", "voz:siguiente", "parar"):
|
||||||
|
p.pulsado("accion", orden)
|
||||||
|
time.sleep(1.0)
|
||||||
|
afirma(not boca.dicho, f"no ha hablado ({boca.dicho})")
|
||||||
|
# Desde que la tanda va por tareas, lo que se ve al ejecutar son mensajes
|
||||||
|
# "tarea" (una tarjeta por orden), no "respuesta".
|
||||||
|
hechas = [d for t, d in cara.mensajes[antes:] if t in ("tarea", "respuesta")]
|
||||||
|
afirma(not hechas, f"no ha ejecutado nada ({len(hechas)} tareas o respuestas)")
|
||||||
|
# Solo se miran las respuestas a lo pulsado: la telemetria sigue latiendo
|
||||||
|
# en su hilo cada segundo y se cuela entre medias.
|
||||||
|
contestaciones = [t for t, _ in cara.mensajes[antes:] if t != "telemetria"]
|
||||||
|
afirma(contestaciones and all(t == "bloqueo" for t in contestaciones),
|
||||||
|
f"a cada intento contesta pidiendo la contraseña ({contestaciones})")
|
||||||
|
|
||||||
|
print("\n una contraseña mala se rechaza")
|
||||||
|
antes = len(cara.mensajes)
|
||||||
|
p.pulsado("accion", "desbloquear:no-es-esta-contrasena-12345")
|
||||||
|
time.sleep(0.5)
|
||||||
|
afirma(not p.desbloqueado, "sigue bloqueado")
|
||||||
|
ultimos = cara.de("bloqueo")[-1:] or [{}]
|
||||||
|
afirma(ultimos[0].get("error") is True, "y lo dice como error")
|
||||||
|
afirma(not cara.de("desbloqueado"), "no manda 'desbloqueado'")
|
||||||
|
|
||||||
|
print("\n una vacia ni se intenta")
|
||||||
|
antes = len(cara.mensajes)
|
||||||
|
p.pulsado("accion", "desbloquear:")
|
||||||
|
afirma(len(cara.mensajes) == antes, "no molesta a sudo con una clave vacia")
|
||||||
|
|
||||||
|
print("\n sin candado, obedece")
|
||||||
|
cara2, boca2 = CaraFalsa(), BocaMuda()
|
||||||
|
p2 = Panel(cara2, boca2, manos, candado=False)
|
||||||
|
p2.arranca()
|
||||||
|
afirma(p2.desbloqueado, "nace desbloqueado")
|
||||||
|
afirma(not cara2.de("bloqueo"), "no pide contraseña")
|
||||||
|
p2.pulsado("accion", "prueba")
|
||||||
|
time.sleep(3.0)
|
||||||
|
tarjetas = {d["id"] for d in cara2.de("tarea")}
|
||||||
|
afirma(bool(tarjetas), f"ejecuta de verdad ({len(tarjetas)} tarjetas)")
|
||||||
|
afirma(any(d["estado"] == "hecha" for d in cara2.de("tarea")),
|
||||||
|
"y las tareas llegan a terminar")
|
||||||
|
|
||||||
|
print("\n y se puede volver a echar")
|
||||||
|
p2.bloquea()
|
||||||
|
afirma(not p2.desbloqueado, "bloquea() cierra aunque arrancara sin candado")
|
||||||
|
antes = len(cara2.mensajes)
|
||||||
|
p2.pulsado("accion", "prueba")
|
||||||
|
time.sleep(0.6)
|
||||||
|
afirma(not [d for t, d in cara2.mensajes[antes:] if t in ("tarea", "respuesta")],
|
||||||
|
"y despues de cerrar ya no obedece")
|
||||||
|
|
||||||
|
p.para(); p2.para()
|
||||||
|
print(f"\n {'todo en orden' if not fallos else str(len(fallos)) + ' fallan'}\n")
|
||||||
|
return 1 if fallos else 0
|
||||||
|
|
||||||
|
|
||||||
|
if __name__ == "__main__":
|
||||||
|
sys.exit(main())
|
||||||
122
nucleo/pruebas/prueba_cara.py
Executable file
122
nucleo/pruebas/prueba_cara.py
Executable file
|
|
@ -0,0 +1,122 @@
|
||||||
|
#!/usr/bin/env python3
|
||||||
|
"""El panel: que lo que manda el nucleo sea lo que el HUD sabe leer.
|
||||||
|
|
||||||
|
./venv/bin/python pruebas/prueba_cara.py
|
||||||
|
|
||||||
|
## Por que existe esta prueba
|
||||||
|
|
||||||
|
Montando la telemetria, `ps` devolvia el uso de CPU como cadena y el nucleo la
|
||||||
|
mandaba tal cual. El HUD hace `p.cpu.toFixed(0)`, y una cadena no tiene
|
||||||
|
`toFixed`: la excepcion abortaba el manejador ENTERO y se llevaba por delante
|
||||||
|
todo lo que se pinta despues. En pantalla se veia que CPU, RAM y grafica
|
||||||
|
salian en "--", y el fallo no apuntaba a los procesos por ningun lado.
|
||||||
|
|
||||||
|
Ese es el problema de un puente sin contrato: un campo con el tipo equivocado
|
||||||
|
apaga media pantalla y no dice donde. Aqui se fija el contrato —que campo, de
|
||||||
|
que tipo y en que unidad— comprobando ademas que `hud.js` lo sigue usando asi,
|
||||||
|
para que enterarse no dependa de mirar la pantalla.
|
||||||
|
"""
|
||||||
|
import json
|
||||||
|
import os
|
||||||
|
import re
|
||||||
|
import sys
|
||||||
|
|
||||||
|
AQUI = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
|
||||||
|
sys.path.insert(0, AQUI)
|
||||||
|
|
||||||
|
from cara.panel import Telemetria # noqa: E402
|
||||||
|
|
||||||
|
HUD = os.path.join(AQUI, "cara", "hud")
|
||||||
|
|
||||||
|
fallos = []
|
||||||
|
|
||||||
|
|
||||||
|
def afirma(condicion, queja):
|
||||||
|
print(f" {'OK ' if condicion else 'MAL'} {queja}")
|
||||||
|
if not condicion:
|
||||||
|
fallos.append(queja)
|
||||||
|
|
||||||
|
|
||||||
|
def numero(v):
|
||||||
|
return isinstance(v, (int, float)) and not isinstance(v, bool)
|
||||||
|
|
||||||
|
|
||||||
|
def main() -> int:
|
||||||
|
print("\n el puente esta puesto")
|
||||||
|
with open(os.path.join(HUD, "index.html"), encoding="utf-8") as f:
|
||||||
|
html = f.read()
|
||||||
|
afirma("puente.js" in html, "index.html carga puente.js")
|
||||||
|
# Se comparan las etiquetas <script>, no el texto suelto: el comentario que
|
||||||
|
# hay encima menciona hud.js y una busqueda ingenua lo encuentra antes.
|
||||||
|
scripts = re.findall(r'<script\s+src="([^"]+)"', html)
|
||||||
|
afirma("puente.js" in scripts and "hud.js" in scripts
|
||||||
|
and scripts.index("puente.js") < scripts.index("hud.js"),
|
||||||
|
"y lo carga ANTES que hud.js, que pregunta por window.webkit al arrancar")
|
||||||
|
with open(os.path.join(HUD, "puente.js"), encoding="utf-8") as f:
|
||||||
|
puente = f.read()
|
||||||
|
afirma("WebSocket" in puente, "el puente habla por WebSocket")
|
||||||
|
afirma("messageHandlers" in puente,
|
||||||
|
"suplanta window.webkit, asi hud.js no se toca")
|
||||||
|
afirma("cola" in puente, "guarda lo pulsado mientras reconecta")
|
||||||
|
|
||||||
|
print("\n la telemetria: campos, tipos y unidades")
|
||||||
|
d = Telemetria().lee()
|
||||||
|
Telemetria().lee() # el segundo tiene ya las diferencias de cpu
|
||||||
|
|
||||||
|
afirma(numero(d.get("cpu")), "cpu es un numero")
|
||||||
|
afirma(isinstance(d.get("nucleos"), list) and all(numero(x) for x in d["nucleos"]),
|
||||||
|
f"nucleos es una lista de numeros ({len(d.get('nucleos', []))})")
|
||||||
|
for clave in ("ram", "swap"):
|
||||||
|
v = d.get(clave, {})
|
||||||
|
afirma(numero(v.get("usada")) and numero(v.get("total")),
|
||||||
|
f"{clave} lleva usada y total")
|
||||||
|
afirma(0 < v.get("total", 0) < 1024,
|
||||||
|
f"{clave} viene en GB, no en MB ({v.get('total', 0):.1f})")
|
||||||
|
disco = d.get("disco", {})
|
||||||
|
afirma(0 < disco.get("total", 0) < 200,
|
||||||
|
f"disco viene en TB, no en GB ({disco.get('total', 0):.2f})")
|
||||||
|
afirma(isinstance(d.get("carga"), list),
|
||||||
|
"carga es una lista: el HUD hace carga.map()")
|
||||||
|
afirma(d.get("uptime", 0) > 60,
|
||||||
|
"uptime va en segundos: el HUD decide solo si pone minutos o dias")
|
||||||
|
|
||||||
|
if "gpu" in d:
|
||||||
|
g = d["gpu"]
|
||||||
|
afirma(all(numero(g.get(k)) for k in ("uso", "vram_usada", "vram_total")),
|
||||||
|
"la grafica manda uso, vram_usada y vram_total")
|
||||||
|
afirma(0 < g.get("vram_total", 0) < 128,
|
||||||
|
f"la vram viene en GB ({g.get('vram_total', 0):.1f})")
|
||||||
|
|
||||||
|
print("\n los procesos: el campo que apago media pantalla")
|
||||||
|
procs = d.get("procesos", [])
|
||||||
|
afirma(bool(procs), f"llegan procesos ({len(procs)})")
|
||||||
|
for p in procs[:3]:
|
||||||
|
afirma(numero(p.get("cpu")) and numero(p.get("mem")),
|
||||||
|
f"{p.get('nombre','?')}: cpu y mem son numeros, no cadenas")
|
||||||
|
afirma(all("pid" in p for p in procs), "todos traen pid, que el HUD pone en el title")
|
||||||
|
|
||||||
|
print("\n y el HUD sigue esperando eso mismo")
|
||||||
|
with open(os.path.join(HUD, "hud.js"), encoding="utf-8") as f:
|
||||||
|
js = f.read()
|
||||||
|
# Si alguien cambia hud.js para leer otro campo, esta prueba no lo sabria
|
||||||
|
# mirando solo al nucleo: se comprueba en el propio JavaScript.
|
||||||
|
for campo in ("datos.cpu", "datos.ram", "datos.swap", "datos.disco",
|
||||||
|
"datos.nucleos", "datos.procesos"):
|
||||||
|
afirma(campo in js, f"hud.js lee {campo}")
|
||||||
|
afirma("p.cpu.toFixed" in js,
|
||||||
|
"hud.js llama a toFixed sobre el cpu de cada proceso (por eso tiene que ser numero)")
|
||||||
|
|
||||||
|
# Todo lo que se manda tiene que poder viajar por el socket.
|
||||||
|
print("\n serializable")
|
||||||
|
try:
|
||||||
|
json.dumps(d)
|
||||||
|
afirma(True, "la telemetria entera cabe en JSON")
|
||||||
|
except (TypeError, ValueError) as e:
|
||||||
|
afirma(False, f"la telemetria no es JSON: {e}")
|
||||||
|
|
||||||
|
print(f"\n {'todo en orden' if not fallos else str(len(fallos)) + ' fallan'}\n")
|
||||||
|
return 1 if fallos else 0
|
||||||
|
|
||||||
|
|
||||||
|
if __name__ == "__main__":
|
||||||
|
sys.exit(main())
|
||||||
133
nucleo/pruebas/prueba_dialogo.py
Executable file
133
nucleo/pruebas/prueba_dialogo.py
Executable file
|
|
@ -0,0 +1,133 @@
|
||||||
|
#!/usr/bin/env python3
|
||||||
|
"""Pulsar una accion PREGUNTA lo que falta y la hace.
|
||||||
|
|
||||||
|
./venv/bin/python pruebas/prueba_dialogo.py
|
||||||
|
|
||||||
|
Antes, pulsar en "sabe hacer" recitaba la frase que dispara la accion. Eso es un
|
||||||
|
manual de instrucciones, y uno pulsa justo porque no quiere leerse el manual.
|
||||||
|
|
||||||
|
Lo que se comprueba, por orden de importancia:
|
||||||
|
|
||||||
|
1. que lo destructivo NO se dispare de un clic
|
||||||
|
2. que lo destructivo CON argumento pregunte las DOS cosas
|
||||||
|
3. que un "no" cancele de verdad
|
||||||
|
4. que la pregunta caduque, para que una frase suelta media conversacion
|
||||||
|
despues no se tome por la respuesta
|
||||||
|
"""
|
||||||
|
import os
|
||||||
|
import sys
|
||||||
|
import time
|
||||||
|
|
||||||
|
AQUI = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
|
||||||
|
sys.path.insert(0, AQUI)
|
||||||
|
|
||||||
|
from cara.panel import Panel # noqa: E402
|
||||||
|
from manos import Manos # noqa: E402
|
||||||
|
from manos.preguntar import pregunta_por, es_si # noqa: E402
|
||||||
|
|
||||||
|
fallos = []
|
||||||
|
|
||||||
|
|
||||||
|
def afirma(condicion, queja):
|
||||||
|
print(f" {'OK ' if condicion else 'MAL'} {queja}")
|
||||||
|
if not condicion:
|
||||||
|
fallos.append(queja)
|
||||||
|
|
||||||
|
|
||||||
|
class CaraFalsa:
|
||||||
|
conectados = 1
|
||||||
|
def __init__(self): self.m = []
|
||||||
|
def manda(self, t, d): self.m.append((t, d))
|
||||||
|
|
||||||
|
|
||||||
|
class BocaMuda:
|
||||||
|
voz = "davefx"
|
||||||
|
def __init__(self): self.dicho = []
|
||||||
|
def di(self, t): self.dicho.append(t); return True
|
||||||
|
def di_si_libre(self, t): return self.di(t)
|
||||||
|
def disponibles(self): return ["davefx"]
|
||||||
|
|
||||||
|
|
||||||
|
def nuevo():
|
||||||
|
cara, boca = CaraFalsa(), BocaMuda()
|
||||||
|
return Panel(cara, boca, Manos(), candado=False), boca
|
||||||
|
|
||||||
|
|
||||||
|
def main() -> int:
|
||||||
|
print("\n las preguntas salen del catalogo")
|
||||||
|
manos = Manos()
|
||||||
|
conArg = [a for a in manos.catalogo.acciones if a.captura]
|
||||||
|
genericas = [a for a in conArg if pregunta_por(a) == "¿El que, señor?"]
|
||||||
|
afirma(len(conArg) >= 30, f"{len(conArg)} acciones piden argumento")
|
||||||
|
afirma(len(genericas) <= 10,
|
||||||
|
f"solo {len(genericas)} caen en la pregunta generica, de {len(conArg)}")
|
||||||
|
afirma(all(pregunta_por(a).endswith("señor?") for a in conArg),
|
||||||
|
"todas preguntan en el registro de la casa")
|
||||||
|
afirma("cierra" not in [pregunta_por(a).split()[0].strip("¿").lower()
|
||||||
|
for a in conArg],
|
||||||
|
"y ninguna empieza por el verbo de la orden")
|
||||||
|
|
||||||
|
print("\n con argumento: pregunta y ejecuta con lo que le digas")
|
||||||
|
p, boca = nuevo()
|
||||||
|
p.pulsado("accion", "explica:buscar_fichero"); time.sleep(0.2)
|
||||||
|
afirma(bool(p.esperando()), "se queda esperando respuesta")
|
||||||
|
afirma(any("fichero" in d for d in boca.dicho), f"pregunta cual: {boca.dicho}")
|
||||||
|
p.responde("informes"); time.sleep(1.5)
|
||||||
|
tareas = [t.titulo for t in p.tareas.todas()]
|
||||||
|
afirma(any("informes" in t for t in tareas), f"lo ejecuta con el argumento: {tareas}")
|
||||||
|
afirma(not p.esperando(), "y deja de esperar")
|
||||||
|
p.para()
|
||||||
|
|
||||||
|
print("\n lo destructivo NO se dispara de un clic")
|
||||||
|
p, boca = nuevo()
|
||||||
|
p.pulsado("accion", "explica:ff_firefox_cerrar"); time.sleep(0.3)
|
||||||
|
afirma(not p.tareas.todas(), "no ha lanzado nada al pulsar")
|
||||||
|
afirma(bool(p.esperando()), "esta esperando confirmacion")
|
||||||
|
p.responde("no"); time.sleep(0.4)
|
||||||
|
afirma(not p.tareas.todas(), "y con un 'no' sigue sin lanzar nada")
|
||||||
|
p.para()
|
||||||
|
|
||||||
|
print("\n destructivo CON argumento: las dos preguntas")
|
||||||
|
p, boca = nuevo()
|
||||||
|
p.pulsado("accion", "explica:proceso_matar"); time.sleep(0.2)
|
||||||
|
afirma(bool(p.esperando()), "pregunta el argumento")
|
||||||
|
p.responde("firefox"); time.sleep(0.3)
|
||||||
|
afirma(bool(p.esperando()),
|
||||||
|
"y DESPUES pide confirmacion, no ejecuta directo")
|
||||||
|
afirma(any("firefox" in d for d in boca.dicho),
|
||||||
|
"la confirmacion dice sobre que va, no un cheque en blanco")
|
||||||
|
p.responde("no"); time.sleep(0.4)
|
||||||
|
afirma(not p.tareas.todas(), "un 'no' lo cancela")
|
||||||
|
p.para()
|
||||||
|
|
||||||
|
print("\n lo que no pregunta nada, se hace")
|
||||||
|
p, boca = nuevo()
|
||||||
|
p.pulsado("accion", "explica:disco_libre"); time.sleep(1.5)
|
||||||
|
afirma(bool(p.tareas.todas()), "una accion sin argumento ni riesgo se ejecuta")
|
||||||
|
afirma(not p.esperando(), "sin preguntar nada")
|
||||||
|
p.para()
|
||||||
|
|
||||||
|
print("\n la pregunta caduca")
|
||||||
|
p, boca = nuevo()
|
||||||
|
p.ESPERA_S = 0.5
|
||||||
|
p.pulsado("accion", "explica:buscar_fichero"); time.sleep(0.2)
|
||||||
|
afirma(bool(p.esperando()), "recien preguntada, espera")
|
||||||
|
time.sleep(0.8)
|
||||||
|
afirma(not p.esperando(),
|
||||||
|
"pasado el plazo la olvida: una frase suelta media conversacion "
|
||||||
|
"despues no puede tomarse por la respuesta")
|
||||||
|
p.para()
|
||||||
|
|
||||||
|
print("\n el si y el no, como los dice la gente")
|
||||||
|
for t, esperado in [("si", True), ("Sí.", True), ("vale", True),
|
||||||
|
("claro que si", True), ("no", False), ("dejalo", False),
|
||||||
|
("no, mejor no", False), ("informes", None),
|
||||||
|
("el fichero de agosto", None)]:
|
||||||
|
afirma(es_si(t) is esperado, f"{t!r} -> {es_si(t)}")
|
||||||
|
|
||||||
|
print(f"\n {'todo en orden' if not fallos else str(len(fallos)) + ' fallan'}\n")
|
||||||
|
return 1 if fallos else 0
|
||||||
|
|
||||||
|
|
||||||
|
if __name__ == "__main__":
|
||||||
|
sys.exit(main())
|
||||||
159
nucleo/pruebas/prueba_eco.py
Executable file
159
nucleo/pruebas/prueba_eco.py
Executable file
|
|
@ -0,0 +1,159 @@
|
||||||
|
#!/usr/bin/env python3
|
||||||
|
"""La prueba que Newelle no pasa: que JARVIS no se oiga a si mismo.
|
||||||
|
|
||||||
|
En Newelle, mas del 21 % de lo que oye y no entiende es su propia voz. Esta
|
||||||
|
prueba lo comprueba de verdad, con el microfono y los altavoces, en dos partes:
|
||||||
|
|
||||||
|
A. Suena una frase POR FUERA de JARVIS (un reproductor a pelo, como si
|
||||||
|
hablara una persona). Tiene que captarla. Si no, el microfono no llega a
|
||||||
|
los altavoces y la parte B no demuestra nada.
|
||||||
|
|
||||||
|
B. La misma frase, pero dicha POR JARVIS. NO tiene que captarla.
|
||||||
|
|
||||||
|
Las dos partes juntas son la prueba: A sola no dice nada, B sola podria pasar
|
||||||
|
simplemente porque el microfono no oye nada.
|
||||||
|
|
||||||
|
./venv/bin/python pruebas/prueba_eco.py
|
||||||
|
|
||||||
|
Necesita altavoces encendidos y a un volumen normal. Si estan en silencio, la
|
||||||
|
parte A falla y avisa.
|
||||||
|
"""
|
||||||
|
import os
|
||||||
|
import subprocess
|
||||||
|
import sys
|
||||||
|
import threading
|
||||||
|
import time
|
||||||
|
|
||||||
|
AQUI = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
|
||||||
|
sys.path.insert(0, AQUI)
|
||||||
|
|
||||||
|
from boca.voz import Boca # noqa: E402
|
||||||
|
from oido.captura import Captura # noqa: E402
|
||||||
|
from oido.whisper import Oido, es_ruido # noqa: E402
|
||||||
|
|
||||||
|
FRASE = "El sistema esta operativo y a su disposicion, señor."
|
||||||
|
ESPERA = 14 # cuanto se escucha en cada parte
|
||||||
|
|
||||||
|
|
||||||
|
def _se_parece(oido: str, dicho: str) -> bool:
|
||||||
|
"""Si lo transcrito es la frase que se dijo, aunque venga maltratada.
|
||||||
|
|
||||||
|
Se compara por palabras y no por parecido de cadena: un eco recortado
|
||||||
|
("operativo y a su disposicion") no se parece a la frase entera como
|
||||||
|
cadena, pero comparte casi todas sus palabras, y eso es inequivoco.
|
||||||
|
"""
|
||||||
|
import unicodedata
|
||||||
|
|
||||||
|
def palabras(t):
|
||||||
|
t = unicodedata.normalize("NFD", t.lower())
|
||||||
|
t = "".join(c for c in t if unicodedata.category(c) != "Mn")
|
||||||
|
return {p.strip(".,¡!¿?") for p in t.split() if len(p) > 3}
|
||||||
|
|
||||||
|
a, b = palabras(oido), palabras(dicho)
|
||||||
|
return bool(b) and len(a & b) >= 2
|
||||||
|
|
||||||
|
|
||||||
|
def escucha_un_rato(captura, oreja, segundos):
|
||||||
|
"""Devuelve lo que se haya oido en ese rato."""
|
||||||
|
oido = []
|
||||||
|
fin = time.monotonic() + segundos
|
||||||
|
hilo_paro = threading.Event()
|
||||||
|
|
||||||
|
def bucle():
|
||||||
|
for wav in captura.frases(para_cuando=lambda: hilo_paro.is_set()):
|
||||||
|
try:
|
||||||
|
t = oreja.transcribe(wav)
|
||||||
|
finally:
|
||||||
|
try:
|
||||||
|
os.unlink(wav)
|
||||||
|
except OSError:
|
||||||
|
pass
|
||||||
|
if t and not es_ruido(t):
|
||||||
|
oido.append(t)
|
||||||
|
|
||||||
|
h = threading.Thread(target=bucle, daemon=True)
|
||||||
|
h.start()
|
||||||
|
while time.monotonic() < fin:
|
||||||
|
time.sleep(0.2)
|
||||||
|
hilo_paro.set()
|
||||||
|
captura.para()
|
||||||
|
h.join(timeout=5)
|
||||||
|
return oido
|
||||||
|
|
||||||
|
|
||||||
|
def main() -> int:
|
||||||
|
boca = Boca("davefx")
|
||||||
|
oreja = Oido(modelo="small")
|
||||||
|
if not oreja.disponible():
|
||||||
|
print(" no esta whisper o el modelo; no se puede probar")
|
||||||
|
return 2
|
||||||
|
print(" arrancando whisper...")
|
||||||
|
if not oreja.arranca():
|
||||||
|
print(" whisper no arranco")
|
||||||
|
return 2
|
||||||
|
|
||||||
|
# Se genera el WAV una vez para poder reproducirlo por los dos caminos con
|
||||||
|
# exactamente el mismo audio.
|
||||||
|
wav = boca._genera(FRASE)
|
||||||
|
if not wav:
|
||||||
|
print(" no se pudo generar la voz")
|
||||||
|
return 2
|
||||||
|
|
||||||
|
fallos = 0
|
||||||
|
|
||||||
|
# --- A: suena por fuera, tiene que oirse -----------------------------
|
||||||
|
print("\n A · suena por fuera (como si hablara alguien)")
|
||||||
|
captura = Captura(boca=boca)
|
||||||
|
def suelta_fuera():
|
||||||
|
time.sleep(2.5)
|
||||||
|
subprocess.run(["paplay", wav], capture_output=True)
|
||||||
|
threading.Thread(target=suelta_fuera, daemon=True).start()
|
||||||
|
oido_a = escucha_un_rato(captura, oreja, ESPERA)
|
||||||
|
for t in oido_a:
|
||||||
|
print(f" oido: {t!r}")
|
||||||
|
if oido_a:
|
||||||
|
print(" OK el microfono llega a los altavoces")
|
||||||
|
else:
|
||||||
|
print(" MAL no se oyo nada: ¿altavoces en silencio? sin esto la")
|
||||||
|
print(" parte B no demuestra nada")
|
||||||
|
fallos += 1
|
||||||
|
|
||||||
|
time.sleep(1.5)
|
||||||
|
|
||||||
|
# --- B: lo dice JARVIS, NO tiene que oirse ---------------------------
|
||||||
|
print("\n B · lo dice JARVIS (la guarda tiene que taparlo)")
|
||||||
|
captura = Captura(boca=boca)
|
||||||
|
def suelta_jarvis():
|
||||||
|
time.sleep(2.5)
|
||||||
|
boca.di(FRASE)
|
||||||
|
threading.Thread(target=suelta_jarvis, daemon=True).start()
|
||||||
|
oido_b = escucha_un_rato(captura, oreja, ESPERA)
|
||||||
|
|
||||||
|
# Lo que se juzga es si se colo LA FRASE, no si se transcribio algo.
|
||||||
|
#
|
||||||
|
# Esto costo una conclusion equivocada: probando con colas de 350, 700 y
|
||||||
|
# 1100 ms el resultado no era monotono —1100 fallaba y 700 no—, lo cual es
|
||||||
|
# imposible si el unico factor fuera el eco. Mirando lo que se colaba, eran
|
||||||
|
# "¡Adios!" y un parrafo inventado: Whisper ALUCINANDO sobre el silencio,
|
||||||
|
# que es otro problema distinto y da igual lo larga que sea la guarda.
|
||||||
|
eco = [t for t in oido_b if _se_parece(t, FRASE)]
|
||||||
|
alucinado = [t for t in oido_b if t not in eco]
|
||||||
|
|
||||||
|
for t in eco:
|
||||||
|
print(f" ECO: {t!r}")
|
||||||
|
for t in alucinado:
|
||||||
|
print(f" (whisper alucinando sobre el silencio: {t[:52]!r})")
|
||||||
|
|
||||||
|
if not eco:
|
||||||
|
print(" OK JARVIS no se oye a si mismo")
|
||||||
|
else:
|
||||||
|
print(" MAL se ha oido hablar: la guarda no tapa")
|
||||||
|
fallos += 1
|
||||||
|
|
||||||
|
oreja.para()
|
||||||
|
print(f"\n {'todo en orden' if not fallos else str(fallos) + ' fallan'}")
|
||||||
|
return 1 if fallos else 0
|
||||||
|
|
||||||
|
|
||||||
|
if __name__ == "__main__":
|
||||||
|
sys.exit(main())
|
||||||
173
nucleo/pruebas/prueba_manos.py
Executable file
173
nucleo/pruebas/prueba_manos.py
Executable file
|
|
@ -0,0 +1,173 @@
|
||||||
|
#!/usr/bin/env python3
|
||||||
|
"""El emparejador: que siga acertando y, sobre todo, que no se invente ordenes.
|
||||||
|
|
||||||
|
./venv/bin/python pruebas/prueba_manos.py
|
||||||
|
|
||||||
|
Porta las comprobaciones de `pruebas/08_acciones.sh` de la epoca de Newelle y
|
||||||
|
añade las que hacen falta ahora que el emparejador compara tambien por sonido.
|
||||||
|
|
||||||
|
La regla que ordena este fichero: **equivocarse cuesta mas que no reaccionar.**
|
||||||
|
Esto lanza comandos en la maquina; que no entienda una orden es molesto, que
|
||||||
|
ejecute la que no es puede costar trabajo perdido. Por eso las comprobaciones de
|
||||||
|
falsos positivos son las que mandan, y por eso el suelo de acierto va aparte y
|
||||||
|
mas bajo de lo medido: para que una mejora legitima no obligue a tocar el test,
|
||||||
|
pero una regresion de verdad lo tire.
|
||||||
|
"""
|
||||||
|
import json
|
||||||
|
import os
|
||||||
|
import shlex
|
||||||
|
import sys
|
||||||
|
|
||||||
|
AQUI = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
|
||||||
|
sys.path.insert(0, AQUI)
|
||||||
|
|
||||||
|
from manos.acciones import Catalogo # noqa: E402
|
||||||
|
from manos.fonetica import fonetica # noqa: E402
|
||||||
|
from oido.whisper import es_ruido # noqa: E402
|
||||||
|
|
||||||
|
CATALOGO = os.path.join(AQUI, "datos", "acciones.json")
|
||||||
|
BANCO = os.path.join(AQUI, "datos", "banco.json")
|
||||||
|
|
||||||
|
# Medido el 15 de agosto de 2026: 84,7 %. El suelo se pone tres puntos por
|
||||||
|
# debajo para dejar sitio al ruido de un banco de 150, donde una frase es 0,67.
|
||||||
|
SUELO = 81.0
|
||||||
|
|
||||||
|
# Lo que NO puede disparar una accion jamas. Las cinco primeras vienen del test
|
||||||
|
# 08; el resto son conversacion que empieza igual que una orden, que es
|
||||||
|
# exactamente el riesgo de comparar por sonido.
|
||||||
|
CHARLA = [
|
||||||
|
"necesito un abrazo", "quiero contarte una cosa", "necesito pensar",
|
||||||
|
"puedes explicarme como funciona el kernel", "me gustaria que fueramos amigos",
|
||||||
|
"que tal estas", "como te encuentras hoy", "cuentame un chiste",
|
||||||
|
"que opinas de la musica electronica", "me apetece un cafe",
|
||||||
|
"hoy hace un dia estupendo", "estoy pensando en cambiar de trabajo",
|
||||||
|
"quien fue alan turing", "explicame la teoria de la relatividad",
|
||||||
|
"me gusta mucho como suena tu voz", "cuanto tiempo llevas funcionando",
|
||||||
|
"no se que hacer este fin de semana", "que peliculas me recomiendas",
|
||||||
|
"he tenido un dia muy largo", "sabes cantar",
|
||||||
|
"no quiero que abras nada", "no busques nada por ahora",
|
||||||
|
"antes buscabas mejor las cosas", "el disco duro de mi hermano se rompio",
|
||||||
|
"la memoria me falla ultimamente", "que temperatura hace en la calle",
|
||||||
|
"me han abierto una cuenta en el banco", "cierro los ojos y pienso",
|
||||||
|
"mi ventana da al patio", "la pantalla del movil se ha roto",
|
||||||
|
"ese proceso judicial fue largo", "tengo un fichero de esos antiguos",
|
||||||
|
"el kernel de la cuestion es otro", "hablame de la red de metro",
|
||||||
|
"pon atencion a lo que te digo", "sube el animo que no pasa nada",
|
||||||
|
"baja la voz que estan durmiendo", "abre tu corazon",
|
||||||
|
"escanea el documento con la impresora", "mata el tiempo como puedas",
|
||||||
|
"el volumen de trabajo es enorme", "que hora era cuando llegaste",
|
||||||
|
"las descargas de agua fueron fuertes", "mi carpeta de fotos favorita",
|
||||||
|
"el brillo de sus ojos", "conecta conmigo emocionalmente",
|
||||||
|
"quiero que sepas que me importa", "necesito que me escuches",
|
||||||
|
"puedes decirme si estoy equivocado", "me gustaria saber tu opinion",
|
||||||
|
]
|
||||||
|
|
||||||
|
# Como habla la gente de verdad. Sin quitar la cortesia no encajaba ninguna:
|
||||||
|
# era el fallo de casi todas las ordenes reales que se perdian.
|
||||||
|
CON_CORTESIA = [
|
||||||
|
("Necesito que pongas la película de Iron Man.", "pelicula_abrir"),
|
||||||
|
("¿Puedes poner la película de Iron Man?", "pelicula_abrir"),
|
||||||
|
("Necesito que me abras una terminal.", "terminal_abrir"),
|
||||||
|
("¿Podrías abrir una terminal?", "terminal_abrir"),
|
||||||
|
("Me puedes decir cuánto espacio queda.", "disco_libre"),
|
||||||
|
]
|
||||||
|
|
||||||
|
fallos = []
|
||||||
|
|
||||||
|
|
||||||
|
def afirma(condicion, queja):
|
||||||
|
if condicion:
|
||||||
|
print(f" OK {queja}")
|
||||||
|
else:
|
||||||
|
print(f" MAL {queja}")
|
||||||
|
fallos.append(queja)
|
||||||
|
|
||||||
|
|
||||||
|
def main() -> int:
|
||||||
|
cat = Catalogo([CATALOGO])
|
||||||
|
|
||||||
|
print("\n el catalogo")
|
||||||
|
afirma(len(cat.acciones) >= 150, f"{len(cat.acciones)} acciones cargadas")
|
||||||
|
afirma(not cat.errores, f"sin errores de carga ({len(cat.errores)})")
|
||||||
|
ids = [a.id for a in cat.acciones]
|
||||||
|
afirma(len(ids) == len(set(ids)), "no hay ids repetidos")
|
||||||
|
afirma(all(a.acuse for a in cat.acciones), "todas tienen acuse")
|
||||||
|
afirma(all("{argumento" in a.comando for a in cat.acciones if a.captura),
|
||||||
|
"las que capturan argumento lo usan en el comando")
|
||||||
|
afirma(all(a.confirmar for a in cat.acciones if "rm -rf" in a.comando),
|
||||||
|
"nada que borre se ejecuta sin confirmar")
|
||||||
|
|
||||||
|
print("\n entiende como habla la gente")
|
||||||
|
for frase, esperado in CON_CORTESIA:
|
||||||
|
a, _ = cat.busca(frase)
|
||||||
|
afirma(a is not None and a.id == esperado,
|
||||||
|
f"'{frase[:38]}' -> {esperado}"
|
||||||
|
+ ("" if a is None or a.id == esperado else f" (fue a {a.id})"))
|
||||||
|
|
||||||
|
print("\n y NO se inventa ordenes")
|
||||||
|
coladas = [(c, cat.busca(c)[0]) for c in CHARLA]
|
||||||
|
coladas = [(c, a.id) for c, a in coladas if a is not None]
|
||||||
|
afirma(not coladas,
|
||||||
|
f"ninguna de las {len(CHARLA)} frases de charla dispara nada"
|
||||||
|
+ ("" if not coladas else f" — se colo {coladas[0][0]!r} -> {coladas[0][1]}"))
|
||||||
|
|
||||||
|
print("\n el argumento viene de un microfono: no puede ser una orden")
|
||||||
|
for veneno in ["gatos; rm -rf /", 'algo " ; touch /tmp/jarvis_pwned ; "']:
|
||||||
|
a, arg = cat.busca(f"busca en internet {veneno}")
|
||||||
|
if a is None:
|
||||||
|
fallos.append(f"no encaja la busqueda con {veneno!r}")
|
||||||
|
print(f" MAL no encaja la busqueda con {veneno!r}")
|
||||||
|
continue
|
||||||
|
comando = a.comando.replace("{argumento_url}", shlex.quote(arg))
|
||||||
|
comando = comando.replace("{argumento}", shlex.quote(arg))
|
||||||
|
afirma("; rm" not in comando and "; touch" not in comando,
|
||||||
|
f"entrecomillado: {veneno[:24]!r}")
|
||||||
|
|
||||||
|
print("\n el filtro de alucinaciones de Whisper")
|
||||||
|
for t in ["[Música]", "(aplausos)", "[motor]", "¡Suscríbete!", ""]:
|
||||||
|
afirma(es_ruido(t), f"descarta {t!r}")
|
||||||
|
for t in ["cuanto espacio queda", "abre la terminal"]:
|
||||||
|
afirma(not es_ruido(t), f"deja pasar {t!r}")
|
||||||
|
|
||||||
|
print("\n la comparacion por sonido")
|
||||||
|
# Lo que se afirma es que ACERCA, no que iguale: `parecido()` se queda con
|
||||||
|
# el mayor de los dos parecidos, asi que basta con que el del sonido suba.
|
||||||
|
# Exigir igualdad seria pedirle a esto que fuera un Metaphone, y no lo es
|
||||||
|
# a proposito: comprimir mas junta ordenes que no se parecen.
|
||||||
|
import difflib
|
||||||
|
def sube(a, b):
|
||||||
|
letra = difflib.SequenceMatcher(None, a, b).ratio()
|
||||||
|
sonido = difflib.SequenceMatcher(None, fonetica(a), fonetica(b)).ratio()
|
||||||
|
return sonido > letra
|
||||||
|
afirma(sube("abre van kamp", "abre bandcamp"), "'van kamp' se acerca a 'bandcamp'")
|
||||||
|
afirma(fonetica("haz") == fonetica("has"), "'haz' suena igual que 'has'")
|
||||||
|
afirma(fonetica("llave") == fonetica("yave"), "'yave' suena igual que 'llave'")
|
||||||
|
afirma(fonetica("bino") == fonetica("vino"), "la b y la v son el mismo sonido")
|
||||||
|
# Y lo que importa de verdad: que no acerque lo que no se parece.
|
||||||
|
afirma(not sube("abre la terminal", "apaga la pantalla"),
|
||||||
|
"y NO acerca ordenes distintas")
|
||||||
|
|
||||||
|
print("\n el banco fijo")
|
||||||
|
if not os.path.exists(BANCO):
|
||||||
|
print(" ·· no hay banco; crealo con pruebas/banco.py --crear")
|
||||||
|
else:
|
||||||
|
casos = json.load(open(BANCO, encoding="utf-8"))["casos"]
|
||||||
|
bien = otra = 0
|
||||||
|
for c in casos:
|
||||||
|
a, _ = cat.busca(c["oido"])
|
||||||
|
if a is None:
|
||||||
|
continue
|
||||||
|
if a.id == c["id"]:
|
||||||
|
bien += 1
|
||||||
|
else:
|
||||||
|
otra += 1
|
||||||
|
pct = 100 * bien / len(casos)
|
||||||
|
afirma(pct >= SUELO, f"acierto {pct:.1f} % sobre {len(casos)} (suelo {SUELO})")
|
||||||
|
afirma(otra == 0, f"ninguna orden acaba en la accion equivocada ({otra})")
|
||||||
|
|
||||||
|
print(f"\n {'todo en orden' if not fallos else str(len(fallos)) + ' fallan'}\n")
|
||||||
|
return 1 if fallos else 0
|
||||||
|
|
||||||
|
|
||||||
|
if __name__ == "__main__":
|
||||||
|
sys.exit(main())
|
||||||
243
nucleo/pruebas/prueba_voz.py
Executable file
243
nucleo/pruebas/prueba_voz.py
Executable file
|
|
@ -0,0 +1,243 @@
|
||||||
|
#!/usr/bin/env python3
|
||||||
|
"""La cadena de voz entera, con altavoces y microfono de verdad.
|
||||||
|
|
||||||
|
./venv/bin/python pruebas/prueba_voz.py
|
||||||
|
|
||||||
|
Las otras pruebas miran piezas: que el emparejador acierte, que el candado
|
||||||
|
cierre, que el puente mande los campos que el HUD lee. Ninguna contesta a la
|
||||||
|
pregunta que de verdad importa —**si le hablo, ¿me contesta?**— y por eso el
|
||||||
|
fallo de que oia bien pero descartaba en silencio llego hasta el usuario.
|
||||||
|
|
||||||
|
Esta habla por los altavoces y escucha por el microfono, como una persona. Es
|
||||||
|
lenta y necesita el volumen puesto, pero es la unica que prueba lo que se usa.
|
||||||
|
|
||||||
|
## Como funciona
|
||||||
|
|
||||||
|
Se genera la frase con Piper, se reproduce POR FUERA de la boca de JARVIS —con
|
||||||
|
un reproductor a pelo, para que la guarda del eco no la tape— y se mira que la
|
||||||
|
cadena entera reaccione. Que el microfono llega a los altavoces ya lo demuestra
|
||||||
|
prueba_eco.py; aqui se da por hecho y se avisa si falla.
|
||||||
|
|
||||||
|
## Lo que se comprueba, en orden
|
||||||
|
|
||||||
|
1. sin llamarle se oye pero NO se atiende, y se dice por que
|
||||||
|
2. llamandole se atiende y contesta
|
||||||
|
3. encadenando la siguiente sin repetir el nombre
|
||||||
|
4. como lo oye Whisper "Yarvis" y "Charles" tambien valen
|
||||||
|
"""
|
||||||
|
import os
|
||||||
|
import subprocess
|
||||||
|
import sys
|
||||||
|
import threading
|
||||||
|
import time
|
||||||
|
|
||||||
|
AQUI = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
|
||||||
|
sys.path.insert(0, AQUI)
|
||||||
|
|
||||||
|
from boca.voz import Boca # noqa: E402
|
||||||
|
from manos import Manos # noqa: E402
|
||||||
|
from oido.captura import Captura # noqa: E402
|
||||||
|
from oido.despierta import Centinela, NOMBRE # noqa: E402
|
||||||
|
from oido.whisper import Oido, es_ruido # noqa: E402
|
||||||
|
from jarvis import atiende # noqa: E402
|
||||||
|
|
||||||
|
ESPERA = 16 # cuanto se escucha por cada frase dicha
|
||||||
|
fallos = []
|
||||||
|
ajenas = [] # lo que se oyo y no era de la prueba: ruido de la sala
|
||||||
|
|
||||||
|
|
||||||
|
def _se_parece(oido: str, dicho: str) -> bool:
|
||||||
|
"""Si lo transcrito es la frase que se reprodujo, aunque venga maltratada.
|
||||||
|
|
||||||
|
Hace falta porque la prueba usa el microfono de la habitacion: si hay una
|
||||||
|
tele, una conversacion o un video sonando, el bucle oye ESO y una prueba
|
||||||
|
ingenua lo da por bueno. Ha pasado —una pasada dio por valida "¡No te
|
||||||
|
olvides de todo ese chico!"— y una prueba que se cree cualquier ruido no
|
||||||
|
prueba nada.
|
||||||
|
"""
|
||||||
|
import unicodedata
|
||||||
|
|
||||||
|
def palabras(t):
|
||||||
|
t = unicodedata.normalize("NFD", (t or "").lower())
|
||||||
|
t = "".join(c for c in t if unicodedata.category(c) != "Mn")
|
||||||
|
return {p.strip(".,¡!¿?«»") for p in t.split() if len(p) > 3}
|
||||||
|
|
||||||
|
a, b = palabras(oido), palabras(dicho)
|
||||||
|
if not b:
|
||||||
|
return False
|
||||||
|
return len(a & b) >= max(1, min(2, len(b) - 1))
|
||||||
|
|
||||||
|
|
||||||
|
def afirma(condicion, queja):
|
||||||
|
print(f" {'OK ' if condicion else 'MAL'} {queja}")
|
||||||
|
if not condicion:
|
||||||
|
fallos.append(queja)
|
||||||
|
|
||||||
|
|
||||||
|
class Escucha:
|
||||||
|
"""El bucle de voz de jarvis.py, reducido a lo que hace falta probar."""
|
||||||
|
|
||||||
|
def __init__(self, boca, oreja, centinela):
|
||||||
|
self.boca, self.oreja, self.centinela = boca, oreja, centinela
|
||||||
|
self.manos = Manos()
|
||||||
|
self.oido = [] # (texto, atendido, motivo)
|
||||||
|
self.dicho = [] # lo que ha contestado
|
||||||
|
self._para = threading.Event()
|
||||||
|
self._hilo = None
|
||||||
|
|
||||||
|
def arranca(self):
|
||||||
|
self._hilo = threading.Thread(target=self._bucle, daemon=True)
|
||||||
|
self._hilo.start()
|
||||||
|
|
||||||
|
def _bucle(self):
|
||||||
|
cap = Captura(boca=self.boca)
|
||||||
|
for wav in cap.frases(para_cuando=lambda: self._para.is_set()):
|
||||||
|
try:
|
||||||
|
texto = self.oreja.transcribe(wav)
|
||||||
|
finally:
|
||||||
|
try:
|
||||||
|
os.unlink(wav)
|
||||||
|
except OSError:
|
||||||
|
pass
|
||||||
|
if es_ruido(texto):
|
||||||
|
continue
|
||||||
|
|
||||||
|
atender, orden, _ = self.centinela.filtra(texto)
|
||||||
|
if not atender:
|
||||||
|
self.oido.append((texto, False, "no le han llamado"))
|
||||||
|
continue
|
||||||
|
self.oido.append((texto, True, ""))
|
||||||
|
respuesta = atiende(orden, self.manos, None, traza=lambda t: None)
|
||||||
|
if respuesta:
|
||||||
|
self.dicho.append(respuesta)
|
||||||
|
cap.para()
|
||||||
|
|
||||||
|
def para(self):
|
||||||
|
self._para.set()
|
||||||
|
if self._hilo:
|
||||||
|
self._hilo.join(timeout=6)
|
||||||
|
|
||||||
|
def suelta(self, frase, espera=ESPERA):
|
||||||
|
"""Dice la frase POR FUERA de JARVIS y espera a que reaccione.
|
||||||
|
|
||||||
|
Solo cuenta lo que se PARECE a lo reproducido: si hay ruido en la
|
||||||
|
habitacion, el bucle lo oye tambien y darlo por bueno haria pasar la
|
||||||
|
prueba sin haber probado nada.
|
||||||
|
"""
|
||||||
|
antes_oido, antes_dicho = len(self.oido), len(self.dicho)
|
||||||
|
wav = self.boca._genera(frase)
|
||||||
|
if not wav:
|
||||||
|
return None, None
|
||||||
|
time.sleep(0.6)
|
||||||
|
subprocess.run(["paplay", wav], capture_output=True)
|
||||||
|
|
||||||
|
fin = time.monotonic() + espera
|
||||||
|
mio = None
|
||||||
|
while time.monotonic() < fin:
|
||||||
|
for entrada in self.oido[antes_oido:]:
|
||||||
|
if _se_parece(entrada[0], frase):
|
||||||
|
mio = entrada
|
||||||
|
break
|
||||||
|
if mio and (not mio[1] or len(self.dicho) > antes_dicho):
|
||||||
|
break
|
||||||
|
time.sleep(0.2)
|
||||||
|
|
||||||
|
nuevo_dicho = self.dicho[antes_dicho:]
|
||||||
|
ajeno = [o[0] for o in self.oido[antes_oido:] if o is not mio]
|
||||||
|
if ajeno:
|
||||||
|
ajenas.extend(ajeno)
|
||||||
|
print(f" (ruido de la habitacion, ignorado: {ajeno[0][:44]!r})")
|
||||||
|
return mio, (nuevo_dicho[-1] if nuevo_dicho else None)
|
||||||
|
|
||||||
|
|
||||||
|
def main() -> int:
|
||||||
|
boca = Boca("davefx")
|
||||||
|
oreja = Oido(modelo="small")
|
||||||
|
if not oreja.disponible():
|
||||||
|
print(" no esta whisper o el modelo; no se puede probar")
|
||||||
|
return 2
|
||||||
|
print(" arrancando whisper...")
|
||||||
|
if not oreja.arranca():
|
||||||
|
print(" whisper no arranco")
|
||||||
|
return 2
|
||||||
|
|
||||||
|
centinela = Centinela(activo=True)
|
||||||
|
esc = Escucha(boca, oreja, centinela)
|
||||||
|
esc.arranca()
|
||||||
|
time.sleep(1.5)
|
||||||
|
|
||||||
|
print("\n 0 · con la palabra APAGADA (el defecto): atiende directo")
|
||||||
|
centinela.activo = False
|
||||||
|
oido, dicho = esc.suelta("Cuanta memoria queda.")
|
||||||
|
if oido:
|
||||||
|
print(f" oyo: {oido[0]!r}")
|
||||||
|
if dicho:
|
||||||
|
print(f" dijo: {dicho}")
|
||||||
|
afirma(oido is not None and oido[1],
|
||||||
|
"sin exigir el nombre, atiende lo que oiga")
|
||||||
|
afirma(dicho is not None, "y contesta")
|
||||||
|
centinela.activo = True
|
||||||
|
centinela.duerme()
|
||||||
|
|
||||||
|
print("\n 1 · con la palabra puesta y sin llamarle: oye pero no atiende")
|
||||||
|
oido, dicho = esc.suelta("Cuanto espacio queda en el disco.")
|
||||||
|
if oido is None:
|
||||||
|
print(" ·· no se oyo nada: ¿altavoces en silencio? sin esto el resto")
|
||||||
|
print(" de la prueba no demuestra nada")
|
||||||
|
fallos.append("el microfono no capta los altavoces")
|
||||||
|
else:
|
||||||
|
print(f" oyo: {oido[0]!r}")
|
||||||
|
afirma(not oido[1], "lo oye pero no lo atiende, porque no le han llamado")
|
||||||
|
afirma(dicho is None, "y no contesta")
|
||||||
|
|
||||||
|
centinela.duerme()
|
||||||
|
print(f"\n 2 · llamandole por su nombre")
|
||||||
|
oido, dicho = esc.suelta(f"{NOMBRE.capitalize()}, cuanto espacio queda.")
|
||||||
|
if oido:
|
||||||
|
print(f" oyo: {oido[0]!r}")
|
||||||
|
if dicho:
|
||||||
|
print(f" dijo: {dicho}")
|
||||||
|
afirma(oido is not None and oido[1], "lo atiende")
|
||||||
|
afirma(dicho is not None, "y contesta algo")
|
||||||
|
afirma(dicho is not None and any(c.isdigit() for c in dicho),
|
||||||
|
"con una cifra de verdad, no una excusa")
|
||||||
|
|
||||||
|
print("\n 3 · encadenando, sin repetir el nombre")
|
||||||
|
oido, dicho = esc.suelta("Cuanta memoria queda.")
|
||||||
|
if oido:
|
||||||
|
print(f" oyo: {oido[0]!r}")
|
||||||
|
afirma(oido is not None and oido[1],
|
||||||
|
"sigue despierto y atiende sin que le vuelvan a llamar")
|
||||||
|
|
||||||
|
print("\n 4 · como lo oye Whisper de verdad")
|
||||||
|
centinela.duerme()
|
||||||
|
oido, dicho = esc.suelta("Yarvis, que hora es.")
|
||||||
|
if oido:
|
||||||
|
print(f" oyo: {oido[0]!r}")
|
||||||
|
afirma(oido is not None and oido[1],
|
||||||
|
"'Yarvis' tambien le despierta (Whisper escribe el nombre de mil formas)")
|
||||||
|
|
||||||
|
esc.para()
|
||||||
|
oreja.para()
|
||||||
|
|
||||||
|
# Una prueba que usa el microfono de la sala no puede fallar en silencio por
|
||||||
|
# culpa de la sala. Si ha entrado mucho ruido, el resultado no dice nada del
|
||||||
|
# codigo y hay que decirlo, no soltar una pared de MAL.
|
||||||
|
if fallos and len(ajenas) >= 2:
|
||||||
|
print(f"\n ┌─ SALA RUIDOSA ─────────────────────────────────────────")
|
||||||
|
print(f" │ Han entrado {len(ajenas)} frases que no eran de la prueba.")
|
||||||
|
print(f" │ Con audio sonando cerca del microfono, este resultado NO")
|
||||||
|
print(f" │ dice nada del codigo. Ejemplos de lo que se colo:")
|
||||||
|
for a in ajenas[:3]:
|
||||||
|
print(f" │ {a[:52]!r}")
|
||||||
|
print(f" │ Repitelo en silencio.")
|
||||||
|
print(f" └────────────────────────────────────────────────────────")
|
||||||
|
print(f"\n {len(fallos)} fallan, pero no son concluyentes\n")
|
||||||
|
return 2
|
||||||
|
|
||||||
|
print(f"\n {'todo en orden' if not fallos else str(len(fallos)) + ' fallan'}\n")
|
||||||
|
return 1 if fallos else 0
|
||||||
|
|
||||||
|
|
||||||
|
if __name__ == "__main__":
|
||||||
|
sys.exit(main())
|
||||||
175
nucleo/pruebas/repasa_acciones.py
Executable file
175
nucleo/pruebas/repasa_acciones.py
Executable file
|
|
@ -0,0 +1,175 @@
|
||||||
|
#!/usr/bin/env python3
|
||||||
|
"""Ejecuta TODAS las acciones del catalogo y dice cuales funcionan de verdad.
|
||||||
|
|
||||||
|
Por que hace falta: hasta hoy los comandos libres del modelo corrian dentro del
|
||||||
|
sandbox, donde no hay ni el sistema ni los discos. Se arreglo (virtualization a
|
||||||
|
false), pero las 134 acciones del catalogo nunca se habian ejecutado todas
|
||||||
|
seguidas contra la maquina real: la suite prueba que las FRASES caen en la
|
||||||
|
accion correcta, no que el comando de cada accion haga algo util.
|
||||||
|
|
||||||
|
Que se ejecuta y que no:
|
||||||
|
|
||||||
|
- Las destructivas (`confirmar: true`) y las que piden root NO se ejecutan.
|
||||||
|
En uso normal pasan por un dialogo que aprueba una persona; aqui no hay
|
||||||
|
persona, y aprobarlas solas seria justo lo que el diseño evita.
|
||||||
|
- Las que abren ventanas (firefox, xdg-open) se ejecutan solo con --abrir,
|
||||||
|
porque llenan la pantalla. Sin esa opcion se comprueba que el programa
|
||||||
|
existe, que es lo que puede fallar.
|
||||||
|
- El resto se ejecuta entero y se mira que conteste algo con sentido.
|
||||||
|
|
||||||
|
python repasar_acciones.py [--abrir] [--grupo sistema] [--json salida.json]
|
||||||
|
"""
|
||||||
|
import argparse
|
||||||
|
import json
|
||||||
|
import os
|
||||||
|
import re
|
||||||
|
import subprocess
|
||||||
|
import sys
|
||||||
|
import time
|
||||||
|
|
||||||
|
AQUI = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
|
||||||
|
RAIZ = os.path.dirname(AQUI) # la capa JARVIS, para los argumentos de prueba
|
||||||
|
CATALOGO = os.path.join(AQUI, "datos", "acciones.json")
|
||||||
|
|
||||||
|
# Argumentos de mentira para las acciones que capturan uno. Se eligen inocuos:
|
||||||
|
# nada que borre, mueva o mande nada fuera.
|
||||||
|
ARGUMENTOS = {
|
||||||
|
"buscar_fichero": "README.md",
|
||||||
|
"buscar_carpeta": "config",
|
||||||
|
"grep_recursivo": "JARVIS",
|
||||||
|
"leer_fichero": "README.md", # un NOMBRE, que es lo que se dice por voz
|
||||||
|
"abrir_carpeta": RAIZ,
|
||||||
|
"tamano_carpeta": os.path.join(RAIZ, "config"),
|
||||||
|
"buscar_youtube": "musica",
|
||||||
|
"buscar_wikipedia": "madrid",
|
||||||
|
"buscar_github": "newelle",
|
||||||
|
"traducir": "hola",
|
||||||
|
"buscar_web": "que hora es",
|
||||||
|
"matar_proceso": "proceso_que_no_existe_jarvis",
|
||||||
|
"ping": "127.0.0.1",
|
||||||
|
}
|
||||||
|
POR_DEFECTO = "prueba"
|
||||||
|
|
||||||
|
# Lo que abre o MUEVE ventanas. ventanas.sh reordena el escritorio del usuario:
|
||||||
|
# ejecutarlo en un repaso automatico le cambia las ventanas de sitio sin avisar.
|
||||||
|
VENTANA = re.compile(r"\b(firefox|xdg-open|gnome-terminal|nautilus|vlc|mpv|eog|"
|
||||||
|
r"gedit|gnome-text-editor|totem|ventanas\.sh|xdotool|wmctrl)\b")
|
||||||
|
|
||||||
|
|
||||||
|
def carga():
|
||||||
|
with open(CATALOGO, encoding="utf-8") as f:
|
||||||
|
d = json.load(f)
|
||||||
|
return d.get("acciones", d if isinstance(d, list) else [])
|
||||||
|
|
||||||
|
|
||||||
|
def prefijo_host():
|
||||||
|
"""Las acciones llevan host:true y en uso salen del sandbox. Aqui ya
|
||||||
|
estamos fuera, asi que no hace falta prefijo."""
|
||||||
|
return []
|
||||||
|
|
||||||
|
|
||||||
|
def ejecuta(accion, argumento, tope=25):
|
||||||
|
import shlex
|
||||||
|
import urllib.parse
|
||||||
|
|
||||||
|
comando = accion.get("comando") or ""
|
||||||
|
comando = comando.replace("{argumento}", shlex.quote(argumento))
|
||||||
|
comando = comando.replace("{argumento_url}",
|
||||||
|
shlex.quote(urllib.parse.quote_plus(argumento)))
|
||||||
|
t0 = time.monotonic()
|
||||||
|
try:
|
||||||
|
r = subprocess.run(["bash", "-lc", comando], capture_output=True,
|
||||||
|
text=True, errors="replace", timeout=tope)
|
||||||
|
salida = (r.stdout or r.stderr or "").strip()
|
||||||
|
return r.returncode, salida, time.monotonic() - t0
|
||||||
|
except subprocess.TimeoutExpired:
|
||||||
|
return -1, f"(no termino en {tope}s)", time.monotonic() - t0
|
||||||
|
except OSError as e:
|
||||||
|
return -2, f"(no se pudo ejecutar: {e})", time.monotonic() - t0
|
||||||
|
|
||||||
|
|
||||||
|
def programa_existe(comando):
|
||||||
|
"""El primer ejecutable de la orden, para las que abren o mueven ventanas.
|
||||||
|
|
||||||
|
Algunos son ordenes del PATH (firefox) y otros son scripts nuestros con
|
||||||
|
ruta completa (config/ventanas.sh): `command -v` solo sirve para los
|
||||||
|
primeros, y con los segundos hay que mirar el fichero.
|
||||||
|
"""
|
||||||
|
m = VENTANA.search(comando)
|
||||||
|
if not m:
|
||||||
|
return None
|
||||||
|
nombre = m.group(1)
|
||||||
|
if nombre.endswith(".sh"):
|
||||||
|
# sacar la ruta entera tal como aparece en el comando
|
||||||
|
for trozo in comando.split():
|
||||||
|
if trozo.endswith(nombre):
|
||||||
|
ruta = os.path.expandvars(os.path.expanduser(trozo))
|
||||||
|
return os.access(ruta, os.X_OK)
|
||||||
|
return False
|
||||||
|
return subprocess.run(["bash", "-lc", f"command -v {nombre}"],
|
||||||
|
capture_output=True).returncode == 0
|
||||||
|
|
||||||
|
|
||||||
|
def main():
|
||||||
|
p = argparse.ArgumentParser()
|
||||||
|
p.add_argument("--abrir", action="store_true",
|
||||||
|
help="ejecutar tambien las que abren ventanas")
|
||||||
|
p.add_argument("--grupo")
|
||||||
|
p.add_argument("--json")
|
||||||
|
p.add_argument("--tope", type=int, default=25)
|
||||||
|
args = p.parse_args()
|
||||||
|
|
||||||
|
acciones = carga()
|
||||||
|
if args.grupo:
|
||||||
|
acciones = [a for a in acciones if a.get("grupo") == args.grupo]
|
||||||
|
|
||||||
|
resultados = []
|
||||||
|
print(f" repasando {len(acciones)} acciones"
|
||||||
|
f"{' del grupo ' + args.grupo if args.grupo else ''}\n", flush=True)
|
||||||
|
|
||||||
|
for a in acciones:
|
||||||
|
ident = a.get("id", "?")
|
||||||
|
comando = a.get("comando") or ""
|
||||||
|
arg = ARGUMENTOS.get(ident, POR_DEFECTO if a.get("captura") else "")
|
||||||
|
|
||||||
|
if not comando:
|
||||||
|
estado, detalle = "solo habla", a.get("acuse", "")[:50]
|
||||||
|
elif a.get("confirmar") or "sudo" in comando:
|
||||||
|
# no se aprueban solas: en uso las aprueba una persona
|
||||||
|
estado, detalle = "saltada", "destructiva o con root"
|
||||||
|
elif VENTANA.search(comando) and not args.abrir:
|
||||||
|
hay = programa_existe(comando)
|
||||||
|
estado = "programa ok" if hay else "FALTA PROGRAMA"
|
||||||
|
detalle = VENTANA.search(comando).group(1)
|
||||||
|
else:
|
||||||
|
codigo, salida, tardo = ejecuta(a, arg, args.tope)
|
||||||
|
una_linea = " ".join(salida.split())[:70]
|
||||||
|
if codigo == 0:
|
||||||
|
estado = "ok" if salida else "ok (sin salida)"
|
||||||
|
else:
|
||||||
|
estado = f"FALLO ({codigo})"
|
||||||
|
detalle = f"{tardo:4.1f}s {una_linea}"
|
||||||
|
|
||||||
|
resultados.append({"id": ident, "grupo": a.get("grupo"),
|
||||||
|
"estado": estado, "detalle": detalle})
|
||||||
|
marca = "!" if "FALLO" in estado or "FALTA" in estado else " "
|
||||||
|
print(f" {marca} {ident:26s} {estado:16s} {detalle}", flush=True)
|
||||||
|
|
||||||
|
print()
|
||||||
|
from collections import Counter
|
||||||
|
c = Counter(r["estado"].split(" (")[0].split(" ")[0] for r in resultados)
|
||||||
|
for k, v in c.most_common():
|
||||||
|
print(f" {v:3d} {k}")
|
||||||
|
malas = [r for r in resultados if "FALLO" in r["estado"] or "FALTA" in r["estado"]]
|
||||||
|
print(f"\n {len(resultados) - len(malas)} de {len(resultados)} responden bien")
|
||||||
|
if malas:
|
||||||
|
print(" fallan: " + ", ".join(r["id"] for r in malas))
|
||||||
|
|
||||||
|
if args.json:
|
||||||
|
with open(args.json, "w", encoding="utf-8") as f:
|
||||||
|
json.dump(resultados, f, ensure_ascii=False, indent=2)
|
||||||
|
return 1 if malas else 0
|
||||||
|
|
||||||
|
|
||||||
|
if __name__ == "__main__":
|
||||||
|
sys.exit(main())
|
||||||
0
nucleo/saber/__init__.py
Normal file
0
nucleo/saber/__init__.py
Normal file
159
nucleo/saber/busca.py
Normal file
159
nucleo/saber/busca.py
Normal file
|
|
@ -0,0 +1,159 @@
|
||||||
|
"""Buscar en el saber de COFRE lo que hace falta para contestar una pregunta.
|
||||||
|
|
||||||
|
Esto es la mitad "recuperar" de RAG: dada una pregunta, devuelve los fragmentos
|
||||||
|
de los apuntes que mas se le parecen, para pasarselos al cerebro. El cerebro
|
||||||
|
construye la respuesta desde ESE texto, no desde lo que recuerde, que es lo que
|
||||||
|
evita que se invente flags.
|
||||||
|
|
||||||
|
## Por que se carga una vez y se guarda
|
||||||
|
|
||||||
|
El indice son 2.866 vectores. Cargarlo y encodear la pregunta cuesta, pero solo
|
||||||
|
la primera vez: el modelo y los vectores se quedan en memoria. Una consulta
|
||||||
|
despues es un producto escalar contra 2.866 filas, milisegundos.
|
||||||
|
|
||||||
|
## Por que no una base de datos vectorial
|
||||||
|
|
||||||
|
FAISS, Chroma y compañia son para millones de vectores. Con 2.866, numpy y un
|
||||||
|
producto escalar es mas rapido de arrancar, no añade una dependencia pesada, y
|
||||||
|
el indice es un jsonl que se puede abrir y leer con los ojos.
|
||||||
|
"""
|
||||||
|
import json
|
||||||
|
import os
|
||||||
|
|
||||||
|
AQUI = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
|
||||||
|
INDICE = os.path.join(AQUI, "datos", "saber.jsonl")
|
||||||
|
|
||||||
|
_modelo = None
|
||||||
|
_entradas = None
|
||||||
|
_matriz = None
|
||||||
|
|
||||||
|
|
||||||
|
def _carga():
|
||||||
|
global _modelo, _entradas, _matriz
|
||||||
|
if _entradas is not None:
|
||||||
|
return _entradas is not False
|
||||||
|
|
||||||
|
if not os.path.exists(INDICE):
|
||||||
|
_entradas = False
|
||||||
|
return False
|
||||||
|
|
||||||
|
import numpy as np
|
||||||
|
from model2vec import StaticModel
|
||||||
|
|
||||||
|
entradas, vectores = [], []
|
||||||
|
with open(INDICE, encoding="utf-8") as f:
|
||||||
|
for l in f:
|
||||||
|
try:
|
||||||
|
d = json.loads(l)
|
||||||
|
except json.JSONDecodeError:
|
||||||
|
continue
|
||||||
|
v = d.pop("v", None)
|
||||||
|
if v is None:
|
||||||
|
continue
|
||||||
|
entradas.append(d)
|
||||||
|
vectores.append(v)
|
||||||
|
|
||||||
|
_entradas = entradas
|
||||||
|
_matriz = np.array(vectores, dtype="float32")
|
||||||
|
# normalizar una vez: asi la similitud es un simple producto escalar
|
||||||
|
normas = np.linalg.norm(_matriz, axis=1, keepdims=True)
|
||||||
|
_matriz = _matriz / np.clip(normas, 1e-9, None)
|
||||||
|
_modelo = StaticModel.from_pretrained("minishlab/potion-multilingual-128M")
|
||||||
|
return True
|
||||||
|
|
||||||
|
|
||||||
|
def _norm(t: str) -> str:
|
||||||
|
import re
|
||||||
|
import unicodedata
|
||||||
|
t = unicodedata.normalize("NFD", (t or "").lower())
|
||||||
|
t = "".join(c for c in t if unicodedata.category(c) != "Mn")
|
||||||
|
return re.sub(r"[^a-z0-9 ]", " ", t)
|
||||||
|
|
||||||
|
|
||||||
|
# El texto normalizado de cada entrada y su nombre, cacheados para el bono.
|
||||||
|
_texto_norm = None
|
||||||
|
_nombre_norm = None
|
||||||
|
|
||||||
|
|
||||||
|
def _bono_palabras(palabras):
|
||||||
|
"""Un vector de bonos, uno por entrada, segun cuantas palabras compartan."""
|
||||||
|
import numpy as np
|
||||||
|
global _texto_norm, _nombre_norm
|
||||||
|
if _texto_norm is None:
|
||||||
|
_texto_norm = [set(_norm(e["texto"]).split()) for e in _entradas]
|
||||||
|
_nombre_norm = [_norm(e.get("herramienta", "")) for e in _entradas]
|
||||||
|
bono = np.zeros(len(_entradas), dtype="float32")
|
||||||
|
for i, (palabras_e, nombre) in enumerate(zip(_texto_norm, _nombre_norm)):
|
||||||
|
comunes = len(palabras & palabras_e)
|
||||||
|
b = 0.08 * comunes # cada palabra compartida suma
|
||||||
|
if nombre and nombre in palabras: # y nombrar la herramienta, mucho
|
||||||
|
b += 0.5
|
||||||
|
bono[i] = b
|
||||||
|
return bono
|
||||||
|
|
||||||
|
|
||||||
|
def busca(pregunta: str, cuantos: int = 5, perfil: str = None) -> list:
|
||||||
|
"""Los fragmentos mas parecidos a la pregunta, mejor primero.
|
||||||
|
|
||||||
|
Cada uno lleva su similitud (0-1), de que herramienta y fichero viene, y el
|
||||||
|
texto. perfil filtra por carpeta de COFRE si se quiere acotar.
|
||||||
|
"""
|
||||||
|
if not _carga() or not pregunta.strip():
|
||||||
|
return []
|
||||||
|
import numpy as np
|
||||||
|
|
||||||
|
q = _modelo.encode([pregunta])[0]
|
||||||
|
q = q / max(float(np.linalg.norm(q)), 1e-9)
|
||||||
|
sim = _matriz @ q
|
||||||
|
|
||||||
|
# Impulso por palabras exactas (busqueda hibrida).
|
||||||
|
#
|
||||||
|
# Los embeddings estaticos fallan cuando la pregunta va en castellano y el
|
||||||
|
# texto en ingles —"cambiar permisos" no se parece a "change file mode
|
||||||
|
# bits"—. Pero si la pregunta NOMBRA la herramienta ("como uso chmod") o
|
||||||
|
# comparte palabras con el texto, eso es una señal fuerte que la similitud
|
||||||
|
# semantica sola no aprovecha. Se suma un bono por cada palabra de la
|
||||||
|
# pregunta que aparezca, y uno grande si coincide el nombre de la
|
||||||
|
# herramienta: asi "usa nmap para..." lleva nmap al primer puesto.
|
||||||
|
palabras = {w for w in _norm(pregunta).split() if len(w) > 3}
|
||||||
|
if palabras:
|
||||||
|
bono = _bono_palabras(palabras)
|
||||||
|
sim = sim + bono
|
||||||
|
|
||||||
|
orden = np.argsort(-sim)[: cuantos * 6]
|
||||||
|
salida, vistos = [], set()
|
||||||
|
for i in orden:
|
||||||
|
e = _entradas[i]
|
||||||
|
if perfil and e.get("perfil") != perfil:
|
||||||
|
continue
|
||||||
|
# sin duplicados: OSCP_APUNTES es copia de los apuntes de primer nivel.
|
||||||
|
# Se comparan los primeros 120 caracteres, que basta para reconocerlos.
|
||||||
|
firma = e["texto"][:120]
|
||||||
|
if firma in vistos:
|
||||||
|
continue
|
||||||
|
vistos.add(firma)
|
||||||
|
salida.append({**e, "sim": round(float(sim[i]), 3)})
|
||||||
|
if len(salida) >= cuantos:
|
||||||
|
break
|
||||||
|
return salida
|
||||||
|
|
||||||
|
|
||||||
|
def contexto(pregunta: str, cuantos: int = 5, minimo: float = 0.35) -> str:
|
||||||
|
"""Lo mismo, pero ya montado como texto para meterle al cerebro.
|
||||||
|
|
||||||
|
Se corta por debajo de `minimo` de similitud: pasarle al modelo fragmentos
|
||||||
|
que no vienen a cuento es lo que le hace mezclar herramientas que no tienen
|
||||||
|
nada que ver. Mejor darle poco y bueno que mucho y ruidoso.
|
||||||
|
"""
|
||||||
|
trozos = [t for t in busca(pregunta, cuantos) if t["sim"] >= minimo]
|
||||||
|
if not trozos:
|
||||||
|
return ""
|
||||||
|
lineas = ["De los apuntes de COFRE del usuario:\n"]
|
||||||
|
for t in trozos:
|
||||||
|
fuente = t.get("fichero") or f"{t['perfil']}/{t['herramienta']}"
|
||||||
|
lineas.append(f"--- {fuente} ---\n{t['texto']}\n")
|
||||||
|
return "\n".join(lineas)
|
||||||
|
|
||||||
|
|
||||||
|
def disponible() -> bool:
|
||||||
|
return os.path.exists(INDICE)
|
||||||
110
nucleo/saber/enriquece/README.md
Normal file
110
nucleo/saber/enriquece/README.md
Normal file
|
|
@ -0,0 +1,110 @@
|
||||||
|
# Enriquecer el RAG a nivel de pentesting profesional
|
||||||
|
|
||||||
|
El RAG del naranja ya funcionaba, pero se dejaba fuera lo mejor que hay en el
|
||||||
|
disco. Medido antes de empezar: **de las 72 notas del `OSCP_Vault` —la
|
||||||
|
metodologia OSCP escrita a mano, con comandos reales— había 0 en el índice.**
|
||||||
|
`indexa.py` las descartaba por dos motivos a la vez: el nombre (`SQL
|
||||||
|
injection.md` no lleva "notas" ni "guia") y la profundidad (viven a 5 niveles).
|
||||||
|
|
||||||
|
Este pipeline las rescata, multiplica su recuperabilidad con preguntas
|
||||||
|
generadas, y **mide** que el resultado es mejor antes de tocar nada.
|
||||||
|
|
||||||
|
## Correrlo
|
||||||
|
|
||||||
|
```bash
|
||||||
|
./correr_noche.sh # las cuatro fases, y decide si promociona
|
||||||
|
./correr_noche.sh --sin-promo # igual, pero deja el vivo intacto
|
||||||
|
```
|
||||||
|
|
||||||
|
Es reanudable: cada fase se salta si ya está hecha, así que si se corta,
|
||||||
|
relanzarlo continúa. La fase larga (síntesis) es reanudable fragmento a
|
||||||
|
fragmento.
|
||||||
|
|
||||||
|
## Las cuatro fases
|
||||||
|
|
||||||
|
| | Script | Qué hace | Coste |
|
||||||
|
|---|---|---|---|
|
||||||
|
| 1 | `cosecha.py` | rescata la metodología de COFRE que faltaba | segundos, CPU |
|
||||||
|
| 2 | `sintetiza.py` | preguntas en castellano por cada fragmento | **horas**, modelo local |
|
||||||
|
| 3 | `reindexa.py` | une todo y calcula vectores → `saber.jsonl.nuevo` | minutos, CPU |
|
||||||
|
| 4 | `evalua.py` | mide recuperación vivo vs candidato | segundos |
|
||||||
|
|
||||||
|
### 1 · Cosecha
|
||||||
|
|
||||||
|
Donde `indexa.py` es prudente (solo ficheros que *parecen* documentación, 3
|
||||||
|
niveles), esto es agresivo con el oro: las carpetas de metodología (OSCP vaults,
|
||||||
|
apuntes, cheatsheets) enteras, sin límite de profundidad. Fuera de ahí pone un
|
||||||
|
**tope por herramienta**: si un repo tiene más de 25 documentos, es una base de
|
||||||
|
datos (exploitdb son 29.925 ficheros), no unos apuntes, y solo se coge su
|
||||||
|
README. Así el oro no se ahoga en ruido.
|
||||||
|
|
||||||
|
### 2 · Síntesis — indexación multi-representación
|
||||||
|
|
||||||
|
El punto flaco de los embeddings estáticos: "cómo saco una shell reversa" no se
|
||||||
|
parece vectorialmente a `bash -i >& /dev/tcp/...`. La solución es **embeber la
|
||||||
|
pregunta y devolver el fragmento**. Por cada fragmento, el modelo local escribe
|
||||||
|
las preguntas que responde; se indexa la pregunta, pero lo que se le muestra al
|
||||||
|
cerebro es el fragmento **literal**.
|
||||||
|
|
||||||
|
Clave: el modelo **solo escribe preguntas, nunca reescribe comandos**. Si
|
||||||
|
inventa una pregunta rara, esa entrada recupera peor y ya está; no corrompe una
|
||||||
|
respuesta. Y el fragmento crudo sigue en el índice por su lado.
|
||||||
|
|
||||||
|
### 3 · Reindexado
|
||||||
|
|
||||||
|
Une el índice vivo (comandos Linux, glosario, fichas), la cosecha y la síntesis;
|
||||||
|
deduplica por prefijo; calcula los vectores con el mismo `model2vec` de siempre.
|
||||||
|
Escribe a `saber.jsonl.nuevo`. **No toca el vivo.** `busca.py` no cambia.
|
||||||
|
|
||||||
|
### 4 · Evaluación
|
||||||
|
|
||||||
|
`eval_set.jsonl` son ~45 preguntas de pentesting con las palabras que un
|
||||||
|
fragmento correcto debe contener. Mide `hit@1`, `hit@5` y similitud media, del
|
||||||
|
índice vivo contra el candidato. Determinista y reproducible, sin juez-LLM.
|
||||||
|
|
||||||
|
## La decisión, y por qué es segura
|
||||||
|
|
||||||
|
El índice vivo **solo se sustituye si la evaluación dice que el candidato es
|
||||||
|
mejor**, y antes se guarda `saber.jsonl.antes-<fecha>`. Si empeora, se queda el
|
||||||
|
vivo y el candidato espera revisión. Siempre reversible con un `cp`.
|
||||||
|
|
||||||
|
## Ficheros que genera (en `../../datos/`)
|
||||||
|
|
||||||
|
cosecha.jsonl la metodología rescatada, sin vectores
|
||||||
|
sintesis.jsonl las preguntas generadas (+ .hecho, el marcador)
|
||||||
|
saber.jsonl.nuevo el índice candidato, con vectores
|
||||||
|
informe_rag.txt los números de la evaluación
|
||||||
|
noche_rag.log el registro de la noche
|
||||||
|
saber.jsonl.antes-* copia del índice anterior, si se promocionó
|
||||||
|
|
||||||
|
## Iteraciones posteriores a la primera noche
|
||||||
|
|
||||||
|
- **Troceado que no tira comandos cortos** (`cosecha.py`). El troceado por
|
||||||
|
encabezado descartaba toda sección de menos de 60 caracteres, y eso perdía
|
||||||
|
el oro: `## Detección time-based` + `' AND SLEEP(5)-- -` son 50. Ahora una
|
||||||
|
sección corta se pega a la siguiente y cada fragmento lleva delante el título
|
||||||
|
de la nota. `SLEEP` pasó de 0 a 13 apariciones en el índice; hit@1 80→82 %.
|
||||||
|
El salto en la métrica es pequeño porque las preguntas que quedan son
|
||||||
|
cross-lingual, y de eso no salva el troceado.
|
||||||
|
|
||||||
|
- **`experimento_embedder.py`** — mide, sin tocar nada, si un transformer (e5,
|
||||||
|
bge) supera al model2vec estático. **Resultado (16 ago): NO compensa.**
|
||||||
|
`intfloat/multilingual-e5-base` empató con el estático (hit@1 86 %, hit@5
|
||||||
|
95 % los dos): arregla las 2 preguntas que el estático fallaba, pero rompe
|
||||||
|
otras 2 distintas. A cambio pediría ~50-150 ms por consulta en CPU y una
|
||||||
|
dependencia de torch en cada búsqueda. Medido antes de cambiar → **el
|
||||||
|
estático se queda.** El trabajo de recuperación lo hace la búsqueda híbrida
|
||||||
|
(coseno + bono por palabras), no el embedder, y por eso subir el embedder no
|
||||||
|
mueve la aguja. Reproducible: `./experimento_embedder.py`.
|
||||||
|
|
||||||
|
- **Re-síntesis limpia** sobre el troceado nuevo (`SABER_BASE` en `reindexa.py`
|
||||||
|
reconstruye desde el índice original en vez de apilar, para no inflar). Da a
|
||||||
|
los comandos rescatados (SLEEP y demás) su gancho-pregunta en castellano, que
|
||||||
|
es lo que de verdad ataca las consultas cross-lingual —no el embedder—.
|
||||||
|
|
||||||
|
## Nota sobre la tarjeta
|
||||||
|
|
||||||
|
La síntesis usa el modelo local por `127.0.0.1:11434`. Fija `qwen3.5:4b-jarvis`
|
||||||
|
(el naranja, que no inventa comandos). Si dejas el TUI verde abierto, ollama
|
||||||
|
tiene que cambiar de modelo en cada petición y la noche va más lenta: para la
|
||||||
|
síntesis más rápida, cierra el verde.
|
||||||
92
nucleo/saber/enriquece/correr_noche.sh
Executable file
92
nucleo/saber/enriquece/correr_noche.sh
Executable file
|
|
@ -0,0 +1,92 @@
|
||||||
|
#!/usr/bin/env bash
|
||||||
|
# El pipeline de la noche: mejora el RAG hasta nivel pentesting profesional.
|
||||||
|
#
|
||||||
|
# ./correr_noche.sh corre las cuatro fases y decide
|
||||||
|
# ./correr_noche.sh --sin-promo igual, pero NO sustituye el indice vivo
|
||||||
|
#
|
||||||
|
# ── Que hace, en orden ─────────────────────────────────────────────────────
|
||||||
|
#
|
||||||
|
# 1. COSECHA rescata la metodologia de COFRE que el indexador se dejaba
|
||||||
|
# (el OSCP_Vault entero, 0 de 72 notas estaban en el indice).
|
||||||
|
# 2. SINTETIZA por cada fragmento, preguntas en castellano que lo encuentran.
|
||||||
|
# Es la fase larga: horas, con el modelo local. Reanudable.
|
||||||
|
# 3. REINDEXA une vivo + cosecha + sintesis y calcula los vectores. Escribe
|
||||||
|
# a saber.jsonl.nuevo. NO toca el indice vivo.
|
||||||
|
# 4. EVALUA mide recuperacion del vivo contra el candidato, con numeros.
|
||||||
|
#
|
||||||
|
# ── No rompe nada ──────────────────────────────────────────────────────────
|
||||||
|
#
|
||||||
|
# El indice vivo solo se sustituye si evalua DICE que el candidato es mejor, y
|
||||||
|
# antes se guarda una copia con fecha. Si el candidato empeora, se queda el
|
||||||
|
# vivo y el candidato espera revision. Reversible siempre.
|
||||||
|
#
|
||||||
|
# Cada fase se salta si ya esta hecha, asi que relanzarlo continua donde iba.
|
||||||
|
set -uo pipefail
|
||||||
|
|
||||||
|
AQUI=$(cd -P "$(dirname "${BASH_SOURCE[0]:-$0}")" && pwd)
|
||||||
|
RAIZ=$(cd -P "$AQUI/../.." && pwd) # .../nucleo
|
||||||
|
DATOS="$RAIZ/datos"
|
||||||
|
PY="$RAIZ/venv/bin/python"
|
||||||
|
[ -x "$PY" ] || PY=python3
|
||||||
|
LOG="$DATOS/noche_rag.log"
|
||||||
|
|
||||||
|
# El modelo NO se fija aqui a proposito: sintetiza.py mira que tiene ollama
|
||||||
|
# cargado y usa ESE, para no forzar cambios en la tarjeta de 4 GB. Si el verde
|
||||||
|
# esta abierto, generara con el verde; si no, cae al naranja. Solo se fuerza si
|
||||||
|
# exportas JARVIS_MODELO tu. Aun asi, para la noche mas rapida y limpia, lo
|
||||||
|
# suyo es cerrar el TUI verde: con un solo modelo ollama no recarga nada.
|
||||||
|
|
||||||
|
PROMO=si
|
||||||
|
[ "${1:-}" = "--sin-promo" ] && PROMO=no
|
||||||
|
|
||||||
|
fecha() { date '+%Y-%m-%d %H:%M:%S'; }
|
||||||
|
fase() { echo "" | tee -a "$LOG"; echo "[$(fecha)] === FASE $* ===" | tee -a "$LOG"; }
|
||||||
|
|
||||||
|
echo "[$(fecha)] arranca el pipeline de la noche (modelo $JARVIS_MODELO)" | tee -a "$LOG"
|
||||||
|
|
||||||
|
# ── 1. COSECHA ─────────────────────────────────────────────────────────────
|
||||||
|
fase "1/4 COSECHA"
|
||||||
|
if [ -s "$DATOS/cosecha.jsonl" ]; then
|
||||||
|
echo " ya hecha ($(wc -l <"$DATOS/cosecha.jsonl") fragmentos), se salta" | tee -a "$LOG"
|
||||||
|
else
|
||||||
|
"$PY" "$AQUI/cosecha.py" 2>&1 | tee -a "$LOG"
|
||||||
|
fi
|
||||||
|
|
||||||
|
# ── 2. SINTETIZA (la larga) ────────────────────────────────────────────────
|
||||||
|
fase "2/4 SINTETIZA (horas; reanudable)"
|
||||||
|
# hecha del todo = el .hecho llego al ultimo fragmento
|
||||||
|
TOTAL=$(wc -l <"$DATOS/cosecha.jsonl")
|
||||||
|
HECHO=$(cat "$DATOS/sintesis.jsonl.hecho" 2>/dev/null || echo -1)
|
||||||
|
if [ "$HECHO" -ge "$((TOTAL - 1))" ] 2>/dev/null; then
|
||||||
|
echo " ya completa ($(wc -l <"$DATOS/sintesis.jsonl" 2>/dev/null || echo 0) preguntas)" | tee -a "$LOG"
|
||||||
|
else
|
||||||
|
"$PY" "$AQUI/sintetiza.py" 2>&1 | tee -a "$LOG"
|
||||||
|
fi
|
||||||
|
|
||||||
|
# ── 3. REINDEXA ────────────────────────────────────────────────────────────
|
||||||
|
fase "3/4 REINDEXA"
|
||||||
|
"$PY" "$AQUI/reindexa.py" 2>&1 | tee -a "$LOG"
|
||||||
|
|
||||||
|
# ── 4. EVALUA ──────────────────────────────────────────────────────────────
|
||||||
|
fase "4/4 EVALUA"
|
||||||
|
INFORME="$DATOS/informe_rag.txt"
|
||||||
|
"$PY" "$AQUI/evalua.py" 2>&1 | tee "$INFORME" | tee -a "$LOG"
|
||||||
|
VEREDICTO=$(grep -oE 'VEREDICTO (PROMOCIONAR|MANTENER)' "$INFORME" | awk '{print $2}' | tail -1)
|
||||||
|
|
||||||
|
# ── Decision ───────────────────────────────────────────────────────────────
|
||||||
|
fase "DECISION"
|
||||||
|
if [ "$PROMO" = no ]; then
|
||||||
|
echo " --sin-promo: dejo el candidato en saber.jsonl.nuevo sin tocar el vivo" | tee -a "$LOG"
|
||||||
|
elif [ "$VEREDICTO" = PROMOCIONAR ]; then
|
||||||
|
COPIA="$DATOS/saber.jsonl.antes-$(date +%Y%m%d-%H%M)"
|
||||||
|
cp "$DATOS/saber.jsonl" "$COPIA"
|
||||||
|
mv "$DATOS/saber.jsonl.nuevo" "$DATOS/saber.jsonl"
|
||||||
|
echo " PROMOCIONADO. El candidato es mejor y ya es el indice vivo." | tee -a "$LOG"
|
||||||
|
echo " copia del anterior: $COPIA" | tee -a "$LOG"
|
||||||
|
echo " para deshacer: cp '$COPIA' '$DATOS/saber.jsonl'" | tee -a "$LOG"
|
||||||
|
else
|
||||||
|
echo " MANTENIDO el vivo: el candidato no mejora la evaluacion." | tee -a "$LOG"
|
||||||
|
echo " candidato en saber.jsonl.nuevo e informe en informe_rag.txt para revisar." | tee -a "$LOG"
|
||||||
|
fi
|
||||||
|
|
||||||
|
echo "[$(fecha)] pipeline terminado" | tee -a "$LOG"
|
||||||
282
nucleo/saber/enriquece/cosecha.py
Executable file
282
nucleo/saber/enriquece/cosecha.py
Executable file
|
|
@ -0,0 +1,282 @@
|
||||||
|
#!/usr/bin/env python3
|
||||||
|
"""Cosecha la metodologia de pentesting que el indexador normal se deja fuera.
|
||||||
|
|
||||||
|
./cosecha.py recorre COFRE y escribe datos/cosecha.jsonl
|
||||||
|
./cosecha.py --cuenta dice que cosecharia, sin escribir
|
||||||
|
|
||||||
|
## Por que existe, aparte de indexa.py
|
||||||
|
|
||||||
|
`indexa.py` es conservador a proposito: solo mira ficheros cuyo NOMBRE parece
|
||||||
|
documentacion (readme, notas, guia...) y no baja mas de 3 niveles. Eso funciona
|
||||||
|
para las herramientas, pero **tira la mejor metodologia que hay en el disco**:
|
||||||
|
|
||||||
|
- El `OSCP_Vault` son 72 notas OSCP escritas a mano —`SQL injection.md`,
|
||||||
|
`Reverse shell.md`, `LFI a RCE.md`, `msfvenom.md`...— con comandos reales y
|
||||||
|
enlaces cruzados. Ninguna entra: el nombre no lleva "notas/guia", y ademas
|
||||||
|
viven en `OSCP_APUNTES/OSCP_Vault/02 - Explotacion web/`, a 5 niveles.
|
||||||
|
- Igual con las cheatsheets y apuntes sueltos de AD, tunneling, privesc.
|
||||||
|
|
||||||
|
Medido antes de escribir esto: **0 de 72 notas del Vault estaban en el indice.**
|
||||||
|
|
||||||
|
Este cosechador es agresivo donde el otro es prudente: en los perfiles
|
||||||
|
ofensivos coge TODO .md/.txt que no sea ruido evidente, a la profundidad que
|
||||||
|
haga falta, y marca de que TEMA es por la carpeta que lo contiene (las del Vault
|
||||||
|
van numeradas: "01 - Enumeracion", "02 - Explotacion web"...).
|
||||||
|
|
||||||
|
No pisa a indexa.py: escribe a un fichero aparte. La union y el deduplicado los
|
||||||
|
hace reindexa.py.
|
||||||
|
"""
|
||||||
|
import argparse
|
||||||
|
import json
|
||||||
|
import os
|
||||||
|
import re
|
||||||
|
import sys
|
||||||
|
import unicodedata
|
||||||
|
|
||||||
|
|
||||||
|
def _norm(t):
|
||||||
|
t = unicodedata.normalize("NFD", (t or "").lower())
|
||||||
|
t = "".join(c for c in t if unicodedata.category(c) != "Mn")
|
||||||
|
return re.sub(r"[^a-z0-9 ]", " ", t)
|
||||||
|
|
||||||
|
AQUI = os.path.dirname(os.path.abspath(__file__))
|
||||||
|
RAIZ = os.path.dirname(os.path.dirname(AQUI)) # .../nucleo
|
||||||
|
COFRE = os.path.expanduser("~/COFRE")
|
||||||
|
SALIDA = os.path.join(RAIZ, "datos", "cosecha.jsonl")
|
||||||
|
|
||||||
|
# Los perfiles ofensivos: aqui vive el saber de pentesting. En estos se cosecha
|
||||||
|
# a lo ancho. (LINUX se queda para indexa.py, que ya lo hace bien con man pages.)
|
||||||
|
PERFILES = ["PENTESTERS", "PHISHERS", "REVERSERS", "DEFACERS", "SNEAKERS",
|
||||||
|
"HARD-WARERS", "PROTECTORS", "ZAPPERS", "AUTOMATAS"]
|
||||||
|
|
||||||
|
# Carpetas de oro: se recorren ENTERAS, sin limite de profundidad, porque su
|
||||||
|
# valor esta justo en las notas hondas.
|
||||||
|
ORO = re.compile(r"(OSCP_APUNTES|OSCP_Vault|TELMO_OSCP|RedTeam-Tools|"
|
||||||
|
r"apuntes|cheat|vault|metodolog|notas)", re.I)
|
||||||
|
|
||||||
|
# Lo que no se mira nunca: dependencias, control de versiones, binarios.
|
||||||
|
IGNORA = re.compile(
|
||||||
|
r"(^|/)(node_modules|\.git|\.obsidian|vendor|dist|build|__pycache__|"
|
||||||
|
r"\.venv|venv|site-packages|target|\.cache|\.github)(/|$)", re.I)
|
||||||
|
|
||||||
|
# Ficheros que son plantilla o licencia, no saber.
|
||||||
|
RUIDO = re.compile(r"(code_of_conduct|contributing|changelog|license|copying|"
|
||||||
|
r"pull_request|issue_template|\.min\.|package-lock)", re.I)
|
||||||
|
|
||||||
|
# Fuera de las carpetas de ORO, solo se coge lo que PARECE documentacion por el
|
||||||
|
# nombre. Es la misma idea que indexa.py, un poco mas ancha (tutorial, writeup,
|
||||||
|
# walkthrough). Sin esto entra cada .md de cada exploit.
|
||||||
|
DOC = re.compile(r"(readme|install|usage|apuntes|notas|trucos|howto|tutorial|"
|
||||||
|
r"walkthrough|writeup|write-up|guide|guia|cheat|manual|tips|"
|
||||||
|
r"metodolog|documentation|docs?)", re.I)
|
||||||
|
|
||||||
|
# Tope de ficheros por herramienta fuera del ORO. exploitdb tiene 29.925 .md:
|
||||||
|
# es una base de datos, no unos apuntes, y meterla entera ahoga el oro. Si una
|
||||||
|
# herramienta pasa de esto, se la trata como repo a granel y solo se coge su
|
||||||
|
# documentacion de primer nivel (README).
|
||||||
|
CAP_FICHEROS = 25
|
||||||
|
|
||||||
|
MIN_FRAGMENTO = 60
|
||||||
|
MAX_FRAGMENTO = 1200
|
||||||
|
MAX_PROFUNDIDAD = 4 # niveles bajo el perfil, salvo en carpetas de ORO
|
||||||
|
|
||||||
|
# Tope de tamano por fichero. Una nota de metodologia son unos pocos KB; un .txt
|
||||||
|
# de 300 MB es una wordlist (SecLists y similares llevan .txt de gigabytes) y
|
||||||
|
# leerlo entero revienta la maquina —la swap de este equipo es de 976 MiB—. Por
|
||||||
|
# encima de esto no es saber, es un diccionario, y no se lee.
|
||||||
|
MAX_BYTES = 512 * 1024
|
||||||
|
|
||||||
|
|
||||||
|
def _profundidad(ruta):
|
||||||
|
return ruta.rstrip("/").count("/")
|
||||||
|
|
||||||
|
|
||||||
|
def _tema(ruta):
|
||||||
|
"""El tema, deducido de la carpeta. Las del Vault van numeradas."""
|
||||||
|
for parte in reversed(ruta.split(os.sep)):
|
||||||
|
# "02 - Explotacion web" -> "explotacion web"
|
||||||
|
m = re.match(r"^\d{2}\s*[-.]\s*(.+)$", parte)
|
||||||
|
if m:
|
||||||
|
return m.group(1).strip().lower()
|
||||||
|
return ""
|
||||||
|
|
||||||
|
|
||||||
|
def _herramienta(ruta, perfil):
|
||||||
|
rel = os.path.relpath(ruta, os.path.join(COFRE, perfil)).split(os.sep)
|
||||||
|
return rel[0] if len(rel) > 1 else perfil
|
||||||
|
|
||||||
|
|
||||||
|
def _prefija(titulo, seccion):
|
||||||
|
"""Lleva el titulo de la nota delante de la seccion, salvo que ya lo tenga.
|
||||||
|
|
||||||
|
Sin esto, un fragmento como "## Deteccion time-based\n' AND SLEEP(5)" no
|
||||||
|
sabe de que va —¿time-based de que?—. Con "(SQL injection) ..." delante, el
|
||||||
|
vector y el cerebro tienen el contexto. Se evita duplicar si el titulo ya
|
||||||
|
aparece en la cabecera de la seccion."""
|
||||||
|
if titulo and _norm(titulo) not in _norm(seccion[:80]):
|
||||||
|
return f"({titulo}) {seccion}"
|
||||||
|
return seccion
|
||||||
|
|
||||||
|
|
||||||
|
def trocea(texto):
|
||||||
|
"""En fragmentos por encabezado, fusionando los cortos y con el titulo.
|
||||||
|
|
||||||
|
Antes se partia por encabezado y se TIRABA toda seccion de menos de 60
|
||||||
|
caracteres. Eso perdia justo lo mejor: una seccion "## Deteccion time-based"
|
||||||
|
con `' AND SLEEP(5)-- -` son 50 caracteres, y es oro. Ahora una seccion
|
||||||
|
corta se PEGA a la siguiente en vez de tirarse, y cada fragmento lleva
|
||||||
|
delante el titulo de la nota para no quedar sin contexto.
|
||||||
|
"""
|
||||||
|
texto = re.sub(r"\A---\n.*?\n---\n", "", texto, flags=re.S)
|
||||||
|
m = re.search(r"^#\s+(.+)", texto, re.M)
|
||||||
|
titulo = m.group(1).strip() if m else ""
|
||||||
|
|
||||||
|
crudas = [s.strip() for s in re.split(r"\n(?=#{1,3}\s)", texto) if s.strip()]
|
||||||
|
|
||||||
|
# fusionar hacia adelante mientras la seccion sea demasiado corta
|
||||||
|
fundidas, i = [], 0
|
||||||
|
while i < len(crudas):
|
||||||
|
sec = crudas[i]
|
||||||
|
while len(sec) < MIN_FRAGMENTO and i + 1 < len(crudas):
|
||||||
|
i += 1
|
||||||
|
sec += "\n\n" + crudas[i]
|
||||||
|
fundidas.append(sec)
|
||||||
|
i += 1
|
||||||
|
# si la ultima quedo corta, se dobla sobre la anterior. Se saca primero y
|
||||||
|
# se indexa despues: fundidas.pop() en el lado derecho ya habria acortado
|
||||||
|
# la lista y fundidas[-2] se saldria de rango.
|
||||||
|
if len(fundidas) >= 2 and len(fundidas[-1]) < MIN_FRAGMENTO:
|
||||||
|
cola = fundidas.pop()
|
||||||
|
fundidas[-1] += "\n\n" + cola
|
||||||
|
|
||||||
|
for sec in fundidas:
|
||||||
|
if len(sec) < MIN_FRAGMENTO:
|
||||||
|
continue # una nota entera diminuta
|
||||||
|
if len(sec) <= MAX_FRAGMENTO:
|
||||||
|
yield _prefija(titulo, sec)
|
||||||
|
else:
|
||||||
|
buf = ""
|
||||||
|
for parrafo in re.split(r"\n\s*\n", sec):
|
||||||
|
if len(buf) + len(parrafo) > MAX_FRAGMENTO and buf:
|
||||||
|
yield _prefija(titulo, buf.strip())
|
||||||
|
buf = ""
|
||||||
|
buf += parrafo + "\n\n"
|
||||||
|
if len(buf.strip()) >= MIN_FRAGMENTO:
|
||||||
|
yield _prefija(titulo, buf.strip())
|
||||||
|
|
||||||
|
|
||||||
|
def _candidato(ruta, fich, en_oro):
|
||||||
|
"""Un fichero vale si es texto, no es ruido, no es enorme, y —fuera del
|
||||||
|
oro— su nombre parece documentacion."""
|
||||||
|
if not fich.lower().endswith((".md", ".txt")):
|
||||||
|
return False
|
||||||
|
if RUIDO.search(fich):
|
||||||
|
return False
|
||||||
|
if not en_oro and not DOC.search(fich):
|
||||||
|
return False
|
||||||
|
try:
|
||||||
|
return os.path.getsize(ruta) <= MAX_BYTES
|
||||||
|
except OSError:
|
||||||
|
return False
|
||||||
|
|
||||||
|
|
||||||
|
def ficheros(perfil):
|
||||||
|
"""Los ficheros a cosechar de un perfil, con el tope por herramienta.
|
||||||
|
|
||||||
|
Se recorre cada herramienta (subcarpeta de primer nivel) por separado para
|
||||||
|
poder contar sus ficheros: si pasa del cap y no es oro, es un repo a granel
|
||||||
|
(exploitdb) y solo se coge su README, no sus 30.000 entradas.
|
||||||
|
"""
|
||||||
|
base = os.path.join(COFRE, perfil)
|
||||||
|
if not os.path.isdir(base):
|
||||||
|
return
|
||||||
|
|
||||||
|
# sueltos en la raiz del perfil (apuntes-ad-pentest.md, trucos_trampas.md)
|
||||||
|
for fich in sorted(os.listdir(base)):
|
||||||
|
ruta = os.path.join(base, fich)
|
||||||
|
if os.path.isfile(ruta) and _candidato(ruta, fich, en_oro=True):
|
||||||
|
yield ruta, True
|
||||||
|
|
||||||
|
for herr in sorted(os.listdir(base)):
|
||||||
|
raiz_h = os.path.join(base, herr)
|
||||||
|
if not os.path.isdir(raiz_h) or herr.startswith("."):
|
||||||
|
continue
|
||||||
|
|
||||||
|
candidatos = []
|
||||||
|
for raiz, dirs, fichs in os.walk(raiz_h):
|
||||||
|
if IGNORA.search(raiz):
|
||||||
|
dirs[:] = []
|
||||||
|
continue
|
||||||
|
en_oro = bool(ORO.search(raiz))
|
||||||
|
if not en_oro and _profundidad(raiz) - _profundidad(raiz_h) > MAX_PROFUNDIDAD:
|
||||||
|
dirs[:] = []
|
||||||
|
continue
|
||||||
|
for fich in sorted(fichs):
|
||||||
|
ruta = os.path.join(raiz, fich)
|
||||||
|
if _candidato(ruta, fich, en_oro):
|
||||||
|
candidatos.append((ruta, en_oro, _profundidad(ruta)))
|
||||||
|
|
||||||
|
del_oro = [c for c in candidatos if c[1]]
|
||||||
|
resto = [c for c in candidatos if not c[1]]
|
||||||
|
|
||||||
|
# el oro entra siempre y entero
|
||||||
|
for ruta, en_oro, _ in del_oro:
|
||||||
|
yield ruta, True
|
||||||
|
|
||||||
|
# el resto, con tope: si es un repo a granel, solo lo mas alto
|
||||||
|
if len(resto) > CAP_FICHEROS:
|
||||||
|
resto.sort(key=lambda c: c[2]) # los menos hondos primero
|
||||||
|
resto = resto[:CAP_FICHEROS]
|
||||||
|
for ruta, en_oro, _ in resto:
|
||||||
|
yield ruta, False
|
||||||
|
|
||||||
|
|
||||||
|
def construye(solo_cuenta=False):
|
||||||
|
salida = []
|
||||||
|
for perfil in PERFILES:
|
||||||
|
n_doc = n_frag = 0
|
||||||
|
for ruta, en_oro in ficheros(perfil):
|
||||||
|
try:
|
||||||
|
with open(ruta, encoding="utf-8", errors="ignore") as f:
|
||||||
|
texto = f.read()
|
||||||
|
except OSError:
|
||||||
|
continue
|
||||||
|
if len(texto.strip()) < MIN_FRAGMENTO:
|
||||||
|
continue
|
||||||
|
tema = _tema(ruta)
|
||||||
|
herr = _herramienta(ruta, perfil)
|
||||||
|
rel = os.path.relpath(ruta, COFRE)
|
||||||
|
hubo = False
|
||||||
|
for trozo in trocea(texto):
|
||||||
|
salida.append({
|
||||||
|
"tipo": "metodologia" if en_oro else "apunte",
|
||||||
|
"herramienta": herr, "perfil": perfil,
|
||||||
|
"fichero": rel, "tema": tema, "texto": trozo,
|
||||||
|
})
|
||||||
|
n_frag += 1
|
||||||
|
hubo = True
|
||||||
|
n_doc += hubo
|
||||||
|
print(f" {perfil:14s} {n_doc:5d} docs {n_frag:6d} fragmentos", flush=True)
|
||||||
|
|
||||||
|
oro = sum(1 for e in salida if e["tipo"] == "metodologia")
|
||||||
|
print(f"\n total: {len(salida)} fragmentos ({oro} de metodologia)", flush=True)
|
||||||
|
if solo_cuenta:
|
||||||
|
return 0
|
||||||
|
|
||||||
|
os.makedirs(os.path.dirname(SALIDA), exist_ok=True)
|
||||||
|
with open(SALIDA, "w", encoding="utf-8") as f:
|
||||||
|
for e in salida:
|
||||||
|
f.write(json.dumps(e, ensure_ascii=False) + "\n")
|
||||||
|
print(f" escrito: {SALIDA}", flush=True)
|
||||||
|
return 0
|
||||||
|
|
||||||
|
|
||||||
|
def main():
|
||||||
|
p = argparse.ArgumentParser()
|
||||||
|
p.add_argument("--cuenta", action="store_true")
|
||||||
|
a = p.parse_args()
|
||||||
|
return construye(solo_cuenta=a.cuenta)
|
||||||
|
|
||||||
|
|
||||||
|
if __name__ == "__main__":
|
||||||
|
sys.exit(main())
|
||||||
45
nucleo/saber/enriquece/eval_set.jsonl
Normal file
45
nucleo/saber/enriquece/eval_set.jsonl
Normal file
|
|
@ -0,0 +1,45 @@
|
||||||
|
{"pregunta": "como saco una shell reversa desde bash", "espera": ["bash -i", "/dev/tcp", "reverse", "nc "]}
|
||||||
|
{"pregunta": "generar un payload de reverse shell con msfvenom", "espera": ["msfvenom", "-p ", "lhost", "payload"]}
|
||||||
|
{"pregunta": "estabilizar una shell tty para que funcione bien", "espera": ["python", "pty", "stty", "script /dev/null"]}
|
||||||
|
{"pregunta": "bypass de login por inyeccion sql", "espera": ["or '1'='1", "or 1=1", "-- -", "union select"]}
|
||||||
|
{"pregunta": "detectar sql injection a ciegas basada en tiempo", "espera": ["sleep", "waitfor", "time-based", "benchmark"]}
|
||||||
|
{"pregunta": "de una sqli a ejecucion de comandos", "espera": ["xp_cmdshell", "load_file", "into outfile", "rce"]}
|
||||||
|
{"pregunta": "explotar un local file inclusion para conseguir rce", "espera": ["lfi", "php://", "log poisoning", "/proc/self/environ", "data://"]}
|
||||||
|
{"pregunta": "probar server side template injection", "espera": ["ssti", "{{7*7", "jinja", "${", "twig"]}
|
||||||
|
{"pregunta": "payload basico de xss para robar cookie", "espera": ["<script", "document.cookie", "onerror", "alert("]}
|
||||||
|
{"pregunta": "inyeccion de comandos en un parametro web", "espera": ["command injection", ";", "| ", "$(", "`", "&&"]}
|
||||||
|
{"pregunta": "saltarme un filtro de subida de ficheros", "espera": ["file upload", "magic bytes", ".phtml", "content-type", "double extension"]}
|
||||||
|
{"pregunta": "descubrir directorios y ficheros ocultos en una web", "espera": ["gobuster", "ffuf", "feroxbuster", "dirb", "wordlist"]}
|
||||||
|
{"pregunta": "path traversal para leer etc passwd", "espera": ["../", "directory traversal", "/etc/passwd", "%2e"]}
|
||||||
|
{"pregunta": "enumerar un servidor smb", "espera": ["smbclient", "enum4linux", "smbmap", "crackmapexec", "139", "445"]}
|
||||||
|
{"pregunta": "escaneo de puertos y servicios con nmap", "espera": ["nmap", "-sv", "-sc", "-p-", "-a "]}
|
||||||
|
{"pregunta": "como paso de usuario normal a root en linux", "espera": ["privesc", "sudo -l", "suid", "linpeas", "gtfobins"]}
|
||||||
|
{"pregunta": "escalada de privilegios en windows", "espera": ["winpeas", "privesc", "seimpersonate", "potato", "token"]}
|
||||||
|
{"pregunta": "ataque dcsync para sacar hashes del dominio", "espera": ["dcsync", "secretsdump", "mimikatz", "lsadump"]}
|
||||||
|
{"pregunta": "pass the hash para autenticarme sin la contrasena", "espera": ["pass-the-hash", "pass the hash", "-hashes", "ntlm", "pth"]}
|
||||||
|
{"pregunta": "kerberoasting para sacar tickets de servicio", "espera": ["kerberoast", "getuserspns", "spn", "ticket"]}
|
||||||
|
{"pregunta": "usar bloodhound para mapear el active directory", "espera": ["bloodhound", "sharphound", "neo4j", "collector"]}
|
||||||
|
{"pregunta": "dumpear credenciales de memoria con mimikatz", "espera": ["mimikatz", "sekurlsa", "logonpasswords", "lsass"]}
|
||||||
|
{"pregunta": "usar impacket para ejecutar comandos remotos", "espera": ["impacket", "psexec", "wmiexec", "smbexec"]}
|
||||||
|
{"pregunta": "crackear un hash con john the ripper", "espera": ["john", "--wordlist", "rockyou", "--format"]}
|
||||||
|
{"pregunta": "crackear hashes con hashcat", "espera": ["hashcat", "-m ", "rockyou", "-a "]}
|
||||||
|
{"pregunta": "ataque de fuerza bruta a un login ssh", "espera": ["hydra", "medusa", "-l ", "-p ", "ssh"]}
|
||||||
|
{"pregunta": "transferir un fichero a la maquina victima", "espera": ["scp", "http.server", "certutil", "wget", "curl", "impacket-smbserver"]}
|
||||||
|
{"pregunta": "montar un tunel para pivotar en la red interna", "espera": ["chisel", "ligolo", "ssh -l", "proxychains", "socks"]}
|
||||||
|
{"pregunta": "pivoting con ssh port forwarding", "espera": ["ssh -l", "ssh -r", "-d ", "port forward", "dynamic"]}
|
||||||
|
{"pregunta": "usar metasploit para explotar un servicio", "espera": ["metasploit", "msfconsole", "use exploit", "set rhost"]}
|
||||||
|
{"pregunta": "escanear vulnerabilidades web con nuclei", "espera": ["nuclei", "-t ", "template", "-u "]}
|
||||||
|
{"pregunta": "escanear un wordpress en busca de fallos", "espera": ["wpscan", "--enumerate", "--url", "plugin"]}
|
||||||
|
{"pregunta": "buscar exploits publicos de un servicio", "espera": ["searchsploit", "exploit-db", "exploitdb"]}
|
||||||
|
{"pregunta": "evadir un antivirus o edr al ejecutar payload", "espera": ["av evasion", "amsi", "bypass", "obfusc", "edr"]}
|
||||||
|
{"pregunta": "hacer un buffer overflow clasico", "espera": ["buffer overflow", "eip", "pattern_create", "badchars", "jmp esp"]}
|
||||||
|
{"pregunta": "filtrado de salida y como saltarmelo", "espera": ["egress", "filtering", "puerto", "443", "outbound"]}
|
||||||
|
{"pregunta": "enumerar usuarios y recursos de un active directory", "espera": ["enum", "ldap", "rpcclient", "net user", "adperti"]}
|
||||||
|
{"pregunta": "atacar autenticacion con credenciales por defecto", "espera": ["authentication", "default", "brute", "credential", "login"]}
|
||||||
|
{"pregunta": "descubrir contenido con fuzzing de parametros", "espera": ["ffuf", "fuzz", "content discovery", "wordlist"]}
|
||||||
|
{"pregunta": "usar burp repeater e intruder para probar peticiones", "espera": ["burp", "repeater", "intruder", "proxy"]}
|
||||||
|
{"pregunta": "escaneo de red para descubrir hosts vivos", "espera": ["nmap", "-sn", "ping sweep", "netdiscover", "arp"]}
|
||||||
|
{"pregunta": "conseguir persistencia tras comprometer una maquina", "espera": ["persistenc", "cron", "scheduled task", "backdoor", "registry"]}
|
||||||
|
{"pregunta": "como escaneo redes wifi y capturo handshakes", "espera": ["airodump", "aircrack", "handshake", "wpa", "airgeddon"]}
|
||||||
|
{"pregunta": "usar crackmapexec para barrer una red windows", "espera": ["crackmapexec", "cme ", "smb", "--shares", "spray"]}
|
||||||
|
{"pregunta": "leer un hash ntlm y reutilizarlo por la red", "espera": ["ntlm", "hash", "relay", "responder", "ntlmrelayx"]}
|
||||||
173
nucleo/saber/enriquece/evalua.py
Executable file
173
nucleo/saber/enriquece/evalua.py
Executable file
|
|
@ -0,0 +1,173 @@
|
||||||
|
#!/usr/bin/env python3
|
||||||
|
"""Mide si el indice candidato recupera mejor que el vivo. Con numeros.
|
||||||
|
|
||||||
|
./evalua.py compara vivo contra saber.jsonl.nuevo
|
||||||
|
./evalua.py A.jsonl B.jsonl compara dos indices cualesquiera
|
||||||
|
|
||||||
|
## Que mide
|
||||||
|
|
||||||
|
Un conjunto de preguntas de pentesting (eval_set.jsonl), cada una con las
|
||||||
|
palabras que un fragmento CORRECTO tiene que contener (un comando, una
|
||||||
|
herramienta, un patron). Para cada indice se busca la pregunta y se mira si
|
||||||
|
alguno de los 5 primeros resultados contiene lo esperado.
|
||||||
|
|
||||||
|
hit@1 la pregunta se resuelve con el PRIMER resultado
|
||||||
|
hit@5 se resuelve con alguno de los cinco primeros
|
||||||
|
sim similitud media del mejor resultado
|
||||||
|
|
||||||
|
La busqueda replica la de busca.py (coseno + bono por palabras) para que la
|
||||||
|
comparacion sea justa: lo unico que cambia entre las dos columnas es el indice.
|
||||||
|
|
||||||
|
## Por que asi y no "le pregunte al modelo si estaba bien"
|
||||||
|
|
||||||
|
Un juez-LLM sobre una tarjeta de 4 GB es lento y ruidoso. Esto es determinista,
|
||||||
|
reproducible y honesto: la palabra esperada esta o no esta en el texto
|
||||||
|
recuperado. Es una cota inferior de la calidad —un fragmento puede ser util sin
|
||||||
|
contener el literal— pero sirve para COMPARAR dos indices, que es lo que decide
|
||||||
|
si se promociona el candidato.
|
||||||
|
"""
|
||||||
|
import json
|
||||||
|
import os
|
||||||
|
import re
|
||||||
|
import sys
|
||||||
|
import unicodedata
|
||||||
|
|
||||||
|
AQUI = os.path.dirname(os.path.abspath(__file__))
|
||||||
|
RAIZ = os.path.dirname(os.path.dirname(AQUI))
|
||||||
|
DATOS = os.path.join(RAIZ, "datos")
|
||||||
|
VIVO = os.path.join(DATOS, "saber.jsonl")
|
||||||
|
NUEVO = os.path.join(DATOS, "saber.jsonl.nuevo")
|
||||||
|
EVAL = os.path.join(AQUI, "eval_set.jsonl")
|
||||||
|
MODELO = "minishlab/potion-multilingual-128M"
|
||||||
|
|
||||||
|
_modelo = None
|
||||||
|
|
||||||
|
|
||||||
|
def _norm(t):
|
||||||
|
t = unicodedata.normalize("NFD", (t or "").lower())
|
||||||
|
t = "".join(c for c in t if unicodedata.category(c) != "Mn")
|
||||||
|
return re.sub(r"[^a-z0-9 ]", " ", t)
|
||||||
|
|
||||||
|
|
||||||
|
def _carga_modelo():
|
||||||
|
global _modelo
|
||||||
|
if _modelo is None:
|
||||||
|
from model2vec import StaticModel
|
||||||
|
_modelo = StaticModel.from_pretrained(MODELO)
|
||||||
|
return _modelo
|
||||||
|
|
||||||
|
|
||||||
|
def _carga_indice(ruta):
|
||||||
|
import numpy as np
|
||||||
|
entradas, vs = [], []
|
||||||
|
with open(ruta, encoding="utf-8") as f:
|
||||||
|
for l in f:
|
||||||
|
try:
|
||||||
|
d = json.loads(l)
|
||||||
|
except json.JSONDecodeError:
|
||||||
|
continue
|
||||||
|
v = d.pop("v", None)
|
||||||
|
if v is None:
|
||||||
|
continue
|
||||||
|
entradas.append(d)
|
||||||
|
vs.append(v)
|
||||||
|
M = np.array(vs, dtype="float32")
|
||||||
|
M /= np.clip(np.linalg.norm(M, axis=1, keepdims=True), 1e-9, None)
|
||||||
|
txt = [set(_norm(e["texto"]).split()) for e in entradas]
|
||||||
|
nom = [_norm(e.get("herramienta", "")) for e in entradas]
|
||||||
|
return entradas, M, txt, nom
|
||||||
|
|
||||||
|
|
||||||
|
def _busca(indice, pregunta, cuantos=5):
|
||||||
|
import numpy as np
|
||||||
|
entradas, M, txt, nom = indice
|
||||||
|
q = _carga_modelo().encode([pregunta])[0]
|
||||||
|
q = q / max(float(np.linalg.norm(q)), 1e-9)
|
||||||
|
sim = M @ q
|
||||||
|
palabras = {w for w in _norm(pregunta).split() if len(w) > 3}
|
||||||
|
if palabras:
|
||||||
|
bono = np.zeros(len(entradas), dtype="float32")
|
||||||
|
for i in range(len(entradas)):
|
||||||
|
b = 0.08 * len(palabras & txt[i])
|
||||||
|
if nom[i] and nom[i] in palabras:
|
||||||
|
b += 0.5
|
||||||
|
bono[i] = b
|
||||||
|
sim = sim + bono
|
||||||
|
orden = np.argsort(-sim)[: cuantos * 4]
|
||||||
|
salida, vistos = [], set()
|
||||||
|
for i in orden:
|
||||||
|
firma = entradas[i]["texto"][:120]
|
||||||
|
if firma in vistos:
|
||||||
|
continue
|
||||||
|
vistos.add(firma)
|
||||||
|
salida.append((float(sim[i]), entradas[i]["texto"]))
|
||||||
|
if len(salida) >= cuantos:
|
||||||
|
break
|
||||||
|
return salida
|
||||||
|
|
||||||
|
|
||||||
|
def evalua(ruta):
|
||||||
|
indice = _carga_indice(ruta)
|
||||||
|
casos = [json.loads(l) for l in open(EVAL, encoding="utf-8") if l.strip()]
|
||||||
|
hit1 = hit5 = 0
|
||||||
|
simtop = 0.0
|
||||||
|
fallos = []
|
||||||
|
for c in casos:
|
||||||
|
esperado = [_norm(k).strip() for k in c["espera"]]
|
||||||
|
res = _busca(indice, c["pregunta"])
|
||||||
|
simtop += res[0][0] if res else 0.0
|
||||||
|
textos = [_norm(t) for _, t in res]
|
||||||
|
acierta = lambda t: any(k and k in t for k in esperado)
|
||||||
|
if res and acierta(textos[0]):
|
||||||
|
hit1 += 1
|
||||||
|
if any(acierta(t) for t in textos):
|
||||||
|
hit5 += 1
|
||||||
|
else:
|
||||||
|
fallos.append(c["pregunta"])
|
||||||
|
n = len(casos)
|
||||||
|
return {"n": n, "hit1": hit1, "hit5": hit5,
|
||||||
|
"sim": simtop / n if n else 0.0, "fallos": fallos}
|
||||||
|
|
||||||
|
|
||||||
|
def _pinta(nombre, r):
|
||||||
|
print(f" {nombre}")
|
||||||
|
print(f" hit@1 {r['hit1']:3d}/{r['n']} ({100*r['hit1']//r['n']}%)")
|
||||||
|
print(f" hit@5 {r['hit5']:3d}/{r['n']} ({100*r['hit5']//r['n']}%)")
|
||||||
|
print(f" sim {r['sim']:.3f}")
|
||||||
|
|
||||||
|
|
||||||
|
def main():
|
||||||
|
a = sys.argv[1] if len(sys.argv) > 1 else VIVO
|
||||||
|
b = sys.argv[2] if len(sys.argv) > 2 else NUEVO
|
||||||
|
if not os.path.exists(b):
|
||||||
|
print(f" no existe el candidato: {b}")
|
||||||
|
return 1
|
||||||
|
|
||||||
|
print("Evaluando el indice VIVO...", flush=True)
|
||||||
|
rv = evalua(a)
|
||||||
|
print("Evaluando el indice CANDIDATO...", flush=True)
|
||||||
|
rn = evalua(b)
|
||||||
|
|
||||||
|
print("\n" + "=" * 44)
|
||||||
|
_pinta("VIVO " + os.path.basename(a), rv)
|
||||||
|
print()
|
||||||
|
_pinta("CANDIDATO " + os.path.basename(b), rn)
|
||||||
|
print("=" * 44)
|
||||||
|
|
||||||
|
mejora5 = rn["hit5"] - rv["hit5"]
|
||||||
|
mejora1 = rn["hit1"] - rv["hit1"]
|
||||||
|
print(f"\n hit@5: {mejora5:+d} hit@1: {mejora1:+d}")
|
||||||
|
|
||||||
|
# el veredicto que lee correr_noche.sh
|
||||||
|
promociona = rn["hit5"] >= rv["hit5"] and rn["hit1"] >= rv["hit1"] - 1
|
||||||
|
print(f" VEREDICTO {'PROMOCIONAR' if promociona else 'MANTENER'}")
|
||||||
|
|
||||||
|
if rn["fallos"]:
|
||||||
|
print(f"\n el candidato aun no resuelve {len(rn['fallos'])}:")
|
||||||
|
for q in rn["fallos"][:12]:
|
||||||
|
print(f" · {q}")
|
||||||
|
return 0
|
||||||
|
|
||||||
|
|
||||||
|
if __name__ == "__main__":
|
||||||
|
sys.exit(main())
|
||||||
142
nucleo/saber/enriquece/experimento_embedder.py
Normal file
142
nucleo/saber/enriquece/experimento_embedder.py
Normal file
|
|
@ -0,0 +1,142 @@
|
||||||
|
#!/usr/bin/env python3
|
||||||
|
"""Experimento: mide si un embedder transformer supera al model2vec estatico.
|
||||||
|
|
||||||
|
./experimento_embedder.py prueba intfloat/multilingual-e5-base
|
||||||
|
./experimento_embedder.py BAAI/bge-m3 prueba otro modelo
|
||||||
|
|
||||||
|
## Por que este experimento
|
||||||
|
|
||||||
|
model2vec (potion-multilingual-128M) es un embedder ESTATICO: rapidisimo (un
|
||||||
|
vector por token, precalculado, sin red neuronal en la consulta) pero flojo en
|
||||||
|
lo semantico. Su punto ciego se ve en las dos preguntas que el RAG no resuelve:
|
||||||
|
|
||||||
|
"detectar sql injection a ciegas basada en tiempo" -> no encuentra SLEEP
|
||||||
|
"descubrir directorios ocultos en una web" -> no encuentra gobuster
|
||||||
|
|
||||||
|
Las dos son cross-lingual: la pregunta va en castellano coloquial y el comando
|
||||||
|
en ingles tecnico ("time-based", "content discovery"). Un transformer de verdad
|
||||||
|
—e5, bge— entiende eso; el estatico no.
|
||||||
|
|
||||||
|
Este experimento NO toca nada: coge una MUESTRA del indice vivo (para que quepa
|
||||||
|
en memoria y sea rapido), la re-embebe con el transformer, y corre la misma
|
||||||
|
evaluacion. Si gana claro, merece la pena cambiar busca.py; si no, no.
|
||||||
|
|
||||||
|
## El coste que habria que pagar si se adopta
|
||||||
|
|
||||||
|
El estatico encodea la consulta en microsegundos. Un transformer en CPU tarda
|
||||||
|
~50-150 ms por consulta. Para un asistente de voz local es asumible, pero no es
|
||||||
|
gratis, y por eso se mide antes de decidir.
|
||||||
|
"""
|
||||||
|
import json
|
||||||
|
import os
|
||||||
|
import re
|
||||||
|
import sys
|
||||||
|
import unicodedata
|
||||||
|
|
||||||
|
AQUI = os.path.dirname(os.path.abspath(__file__))
|
||||||
|
RAIZ = os.path.dirname(os.path.dirname(AQUI))
|
||||||
|
VIVO = os.path.join(RAIZ, "datos", "saber.jsonl")
|
||||||
|
EVAL = os.path.join(AQUI, "eval_set.jsonl")
|
||||||
|
MODELO_TF = sys.argv[1] if len(sys.argv) > 1 else "intfloat/multilingual-e5-base"
|
||||||
|
|
||||||
|
# Muestra: todo lo que un caso de eval podria querer + relleno, para no cargar
|
||||||
|
# 14.000 vectores de transformer en RAM. Se cogen todas las entradas de
|
||||||
|
# metodologia y pregunta (el oro) mas una parte del resto.
|
||||||
|
MAX_ENTRADAS = 6000
|
||||||
|
|
||||||
|
|
||||||
|
def _norm(t):
|
||||||
|
t = unicodedata.normalize("NFD", (t or "").lower())
|
||||||
|
t = "".join(c for c in t if unicodedata.category(c) != "Mn")
|
||||||
|
return re.sub(r"[^a-z0-9 ]", " ", t)
|
||||||
|
|
||||||
|
|
||||||
|
def _muestra():
|
||||||
|
oro, resto = [], []
|
||||||
|
with open(VIVO, encoding="utf-8") as f:
|
||||||
|
for l in f:
|
||||||
|
try:
|
||||||
|
d = json.loads(l)
|
||||||
|
except json.JSONDecodeError:
|
||||||
|
continue
|
||||||
|
(oro if d.get("tipo") in ("metodologia", "pregunta") else resto).append(d)
|
||||||
|
ent = oro + resto[: max(0, MAX_ENTRADAS - len(oro))]
|
||||||
|
return ent
|
||||||
|
|
||||||
|
|
||||||
|
def _eval(nombre, encode_corpus, encode_query, entradas):
|
||||||
|
import numpy as np
|
||||||
|
textos = [(e.get("indexar") or e["texto"]) for e in entradas]
|
||||||
|
M = encode_corpus(textos)
|
||||||
|
M = M / np.clip(np.linalg.norm(M, axis=1, keepdims=True), 1e-9, None)
|
||||||
|
palabras_e = [set(_norm(e["texto"]).split()) for e in entradas]
|
||||||
|
nom = [_norm(e.get("herramienta", "")) for e in entradas]
|
||||||
|
|
||||||
|
casos = [json.loads(l) for l in open(EVAL, encoding="utf-8") if l.strip()]
|
||||||
|
hit1 = hit5 = 0
|
||||||
|
fallos = []
|
||||||
|
for c in casos:
|
||||||
|
q = encode_query([c["pregunta"]])[0]
|
||||||
|
q = q / max(float(np.linalg.norm(q)), 1e-9)
|
||||||
|
sim = M @ q
|
||||||
|
pal = {w for w in _norm(c["pregunta"]).split() if len(w) > 3}
|
||||||
|
if pal:
|
||||||
|
bono = np.array([0.08 * len(pal & palabras_e[i]) +
|
||||||
|
(0.5 if nom[i] and nom[i] in pal else 0.0)
|
||||||
|
for i in range(len(entradas))], dtype="float32")
|
||||||
|
sim = sim + bono
|
||||||
|
orden = np.argsort(-sim)[:5]
|
||||||
|
esperado = [_norm(k).strip() for k in c["espera"]]
|
||||||
|
tops = [_norm(entradas[i]["texto"]) for i in orden]
|
||||||
|
ok = lambda t: any(k and k in t for k in esperado)
|
||||||
|
if tops and ok(tops[0]):
|
||||||
|
hit1 += 1
|
||||||
|
if any(ok(t) for t in tops):
|
||||||
|
hit5 += 1
|
||||||
|
else:
|
||||||
|
fallos.append(c["pregunta"])
|
||||||
|
n = len(casos)
|
||||||
|
print(f"\n {nombre}")
|
||||||
|
print(f" hit@1 {hit1:3d}/{n} ({100*hit1//n}%)")
|
||||||
|
print(f" hit@5 {hit5:3d}/{n} ({100*hit5//n}%)")
|
||||||
|
if fallos:
|
||||||
|
print(f" no resuelve {len(fallos)}: " + "; ".join(fallos[:6]))
|
||||||
|
return hit1, hit5
|
||||||
|
|
||||||
|
|
||||||
|
def main():
|
||||||
|
entradas = _muestra()
|
||||||
|
print(f"Muestra: {len(entradas)} entradas del indice vivo")
|
||||||
|
|
||||||
|
# 1) model2vec estatico, la referencia
|
||||||
|
from model2vec import StaticModel
|
||||||
|
est = StaticModel.from_pretrained("minishlab/potion-multilingual-128M")
|
||||||
|
enc_est = lambda xs: est.encode(xs)
|
||||||
|
h1e, h5e = _eval("model2vec (estatico, el actual)", enc_est, enc_est, entradas)
|
||||||
|
|
||||||
|
# 2) el transformer a prueba
|
||||||
|
print(f"\n cargando {MODELO_TF} (puede descargar ~1-2 GB la 1a vez)...", flush=True)
|
||||||
|
from sentence_transformers import SentenceTransformer
|
||||||
|
tf = SentenceTransformer(MODELO_TF)
|
||||||
|
# los modelos e5 piden prefijos "query:" y "passage:"
|
||||||
|
es_e5 = "e5" in MODELO_TF.lower()
|
||||||
|
enc_doc = lambda xs: tf.encode([("passage: " + x) if es_e5 else x for x in xs],
|
||||||
|
show_progress_bar=False, batch_size=32)
|
||||||
|
enc_q = lambda xs: tf.encode([("query: " + x) if es_e5 else x for x in xs],
|
||||||
|
show_progress_bar=False, batch_size=32)
|
||||||
|
h1t, h5t = _eval(f"{MODELO_TF} (transformer)", enc_doc, enc_q, entradas)
|
||||||
|
|
||||||
|
print("\n" + "=" * 44)
|
||||||
|
print(f" hit@1 estatico {h1e} -> transformer {h1t} ({h1t-h1e:+d})")
|
||||||
|
print(f" hit@5 estatico {h5e} -> transformer {h5t} ({h5t-h5e:+d})")
|
||||||
|
print("=" * 44)
|
||||||
|
if h5t > h5e or (h5t == h5e and h1t > h1e):
|
||||||
|
print(" El transformer gana. Merece plantear el cambio en busca.py")
|
||||||
|
print(" (coste: ~50-150 ms por consulta en CPU, hoy es instantaneo).")
|
||||||
|
else:
|
||||||
|
print(" El transformer NO compensa aqui. El estatico se queda.")
|
||||||
|
return 0
|
||||||
|
|
||||||
|
|
||||||
|
if __name__ == "__main__":
|
||||||
|
sys.exit(main())
|
||||||
113
nucleo/saber/enriquece/reindexa.py
Executable file
113
nucleo/saber/enriquece/reindexa.py
Executable file
|
|
@ -0,0 +1,113 @@
|
||||||
|
#!/usr/bin/env python3
|
||||||
|
"""Construye el indice candidato uniendo lo viejo, lo cosechado y lo sintetizado.
|
||||||
|
|
||||||
|
./reindexa.py escribe datos/saber.jsonl.nuevo (NO toca el vivo)
|
||||||
|
|
||||||
|
## Que une
|
||||||
|
|
||||||
|
1. El indice vivo (datos/saber.jsonl): comandos de Linux, glosario, fichas,
|
||||||
|
servidores... todo lo que cosecha no produce. Se conserva entero.
|
||||||
|
2. cosecha.jsonl: la metodologia de pentesting que faltaba.
|
||||||
|
3. sintesis.jsonl: preguntas en castellano que apuntan a esos fragmentos.
|
||||||
|
|
||||||
|
## Indexacion multi-representacion
|
||||||
|
|
||||||
|
Cada entrada se EMBEBE por su campo `indexar` si lo tiene (las preguntas
|
||||||
|
sintetizadas), y si no por `texto` (todo lo demas). Asi una entrada de pregunta
|
||||||
|
se compara con la consulta del usuario pregunta-contra-pregunta, pero lo que se
|
||||||
|
le muestra al cerebro sigue siendo el fragmento literal de `texto`. busca.py no
|
||||||
|
cambia: solo lee `texto` y `v`.
|
||||||
|
|
||||||
|
## No destruye nada
|
||||||
|
|
||||||
|
Escribe a `saber.jsonl.nuevo`. Quien decide si sustituye al vivo es evalua.py +
|
||||||
|
correr_noche.sh, y solo si mide que es mejor, guardando antes una copia.
|
||||||
|
|
||||||
|
## Deduplicado
|
||||||
|
|
||||||
|
Por los primeros 120 caracteres del texto normalizado (para las entradas
|
||||||
|
normales) o de la pregunta (para las sintetizadas). OSCP_APUNTES duplica apuntes
|
||||||
|
de primer nivel; esto los colapsa.
|
||||||
|
"""
|
||||||
|
import json
|
||||||
|
import os
|
||||||
|
import re
|
||||||
|
import sys
|
||||||
|
import unicodedata
|
||||||
|
|
||||||
|
AQUI = os.path.dirname(os.path.abspath(__file__))
|
||||||
|
RAIZ = os.path.dirname(os.path.dirname(AQUI))
|
||||||
|
DATOS = os.path.join(RAIZ, "datos")
|
||||||
|
# La base son las entradas que cosecha NO produce (comandos Linux, glosario,
|
||||||
|
# fichas). Por defecto el indice vivo, pero se puede fijar con SABER_BASE al
|
||||||
|
# indice ORIGINAL para una reconstruccion limpia que no apile sintesis sobre
|
||||||
|
# sintesis y no infle el indice a cada pasada.
|
||||||
|
VIVO = os.environ.get("SABER_BASE") or os.path.join(DATOS, "saber.jsonl")
|
||||||
|
COSECHA = os.path.join(DATOS, "cosecha.jsonl")
|
||||||
|
SINTESIS = os.path.join(DATOS, "sintesis.jsonl")
|
||||||
|
NUEVO = os.path.join(DATOS, "saber.jsonl.nuevo")
|
||||||
|
|
||||||
|
MODELO = "minishlab/potion-multilingual-128M"
|
||||||
|
|
||||||
|
|
||||||
|
def _norm(t):
|
||||||
|
t = unicodedata.normalize("NFD", (t or "").lower())
|
||||||
|
t = "".join(c for c in t if unicodedata.category(c) != "Mn")
|
||||||
|
return re.sub(r"\s+", " ", re.sub(r"[^a-z0-9 ]", " ", t)).strip()
|
||||||
|
|
||||||
|
|
||||||
|
def _lee(ruta, quita_v=False):
|
||||||
|
if not os.path.exists(ruta):
|
||||||
|
return
|
||||||
|
with open(ruta, encoding="utf-8") as f:
|
||||||
|
for l in f:
|
||||||
|
try:
|
||||||
|
d = json.loads(l)
|
||||||
|
except json.JSONDecodeError:
|
||||||
|
continue
|
||||||
|
if quita_v:
|
||||||
|
d.pop("v", None)
|
||||||
|
yield d
|
||||||
|
|
||||||
|
|
||||||
|
def main():
|
||||||
|
entradas, vistos = [], set()
|
||||||
|
fuentes = [("vivo", VIVO, True), ("cosecha", COSECHA, False),
|
||||||
|
("sintesis", SINTESIS, False)]
|
||||||
|
cuenta = {}
|
||||||
|
for nombre, ruta, quita in fuentes:
|
||||||
|
n = 0
|
||||||
|
for d in _lee(ruta, quita_v=quita):
|
||||||
|
clave_txt = d.get("indexar") or d.get("texto", "")
|
||||||
|
firma = _norm(clave_txt)[:120]
|
||||||
|
if not firma or firma in vistos:
|
||||||
|
continue
|
||||||
|
vistos.add(firma)
|
||||||
|
entradas.append(d)
|
||||||
|
n += 1
|
||||||
|
cuenta[nombre] = n
|
||||||
|
print(f" {nombre:9s} {n:6d} entradas nuevas", flush=True)
|
||||||
|
|
||||||
|
print(f"\n total tras deduplicar: {len(entradas)}", flush=True)
|
||||||
|
|
||||||
|
print(" cargando el modelo de embeddings...", flush=True)
|
||||||
|
from model2vec import StaticModel
|
||||||
|
modelo = StaticModel.from_pretrained(MODELO)
|
||||||
|
|
||||||
|
# se embebe `indexar` si existe (la pregunta), si no `texto`
|
||||||
|
a_embeber = [(e.get("indexar") or e["texto"]) for e in entradas]
|
||||||
|
print(f" calculando {len(a_embeber)} vectores...", flush=True)
|
||||||
|
vectores = modelo.encode(a_embeber, show_progress_bar=False)
|
||||||
|
|
||||||
|
with open(NUEVO, "w", encoding="utf-8") as f:
|
||||||
|
for e, v in zip(entradas, vectores):
|
||||||
|
e["v"] = [round(float(x), 5) for x in v]
|
||||||
|
f.write(json.dumps(e, ensure_ascii=False) + "\n")
|
||||||
|
print(f" escrito: {NUEVO} ({os.path.getsize(NUEVO)//1024} KB)", flush=True)
|
||||||
|
print(f" RESUMEN vivo={cuenta['vivo']} cosecha={cuenta['cosecha']} "
|
||||||
|
f"sintesis={cuenta['sintesis']} total={len(entradas)}", flush=True)
|
||||||
|
return 0
|
||||||
|
|
||||||
|
|
||||||
|
if __name__ == "__main__":
|
||||||
|
sys.exit(main())
|
||||||
207
nucleo/saber/enriquece/sintetiza.py
Executable file
207
nucleo/saber/enriquece/sintetiza.py
Executable file
|
|
@ -0,0 +1,207 @@
|
||||||
|
#!/usr/bin/env python3
|
||||||
|
"""Genera preguntas en castellano para cada fragmento cosechado.
|
||||||
|
|
||||||
|
./sintetiza.py procesa datos/cosecha.jsonl (reanudable, horas)
|
||||||
|
./sintetiza.py --muestra 5 ensena 5 y para
|
||||||
|
|
||||||
|
## Que problema resuelve, y por que no corrompe comandos
|
||||||
|
|
||||||
|
El indice usa embeddings estaticos. Su punto flaco conocido: una pregunta
|
||||||
|
coloquial en castellano —"como saco una shell reversa"— no se parece
|
||||||
|
vectorialmente a un fragmento tecnico en ingles con `bash -i >& /dev/tcp/...`.
|
||||||
|
La busqueda hibrida por palabras ayuda, pero solo si coinciden literales.
|
||||||
|
|
||||||
|
La solucion es **indexacion multi-representacion**: por cada fragmento se generan
|
||||||
|
las preguntas que ese fragmento responde, y se EMBEBE LA PREGUNTA apuntando al
|
||||||
|
fragmento. Asi la consulta del usuario se compara contra otras preguntas, que es
|
||||||
|
comparar peras con peras.
|
||||||
|
|
||||||
|
Clave para no meter la pata: la respuesta que se le muestra al cerebro es el
|
||||||
|
**fragmento original, literal** (campo `texto`). El modelo local solo escribe la
|
||||||
|
PREGUNTA (campo `indexar`). Si inventa una pregunta rara, lo peor que pasa es que
|
||||||
|
esa entrada no recupere bien; **nunca corrompe un comando**, porque no reescribe
|
||||||
|
la respuesta. Y el fragmento crudo sigue en el indice por su lado (lo pone
|
||||||
|
cosecha), asi que la cobertura solo puede subir.
|
||||||
|
|
||||||
|
## El modelo
|
||||||
|
|
||||||
|
Habla con el ollama local. Usa el modelo que ya este CARGADO (mira /api/ps) para
|
||||||
|
no forzar a la tarjeta de 4 GB a cambiar de modelo con el carril verde abierto;
|
||||||
|
si no hay ninguno, carga qwen3.5:4b-jarvis. think:false —qwen3.5 razona por
|
||||||
|
defecto y tardaria 20x—.
|
||||||
|
|
||||||
|
## Reanudable
|
||||||
|
|
||||||
|
Un trabajo de horas no puede perder todo si se corta. Se apunta en un .hecho por
|
||||||
|
que linea de cosecha.jsonl iba, y al arrancar salta hasta ahi. La metodologia
|
||||||
|
(el oro) se procesa PRIMERO, para que si no termina la noche, lo valioso este.
|
||||||
|
"""
|
||||||
|
import argparse
|
||||||
|
import json
|
||||||
|
import os
|
||||||
|
import re
|
||||||
|
import sys
|
||||||
|
import urllib.request
|
||||||
|
|
||||||
|
AQUI = os.path.dirname(os.path.abspath(__file__))
|
||||||
|
RAIZ = os.path.dirname(os.path.dirname(AQUI))
|
||||||
|
COSECHA = os.path.join(RAIZ, "datos", "cosecha.jsonl")
|
||||||
|
SALIDA = os.path.join(RAIZ, "datos", "sintesis.jsonl")
|
||||||
|
MARCA = SALIDA + ".hecho"
|
||||||
|
ENDPOINT = os.environ.get("JARVIS_OLLAMA", "http://127.0.0.1:11434")
|
||||||
|
|
||||||
|
INSTRUCCION = """Eres un generador de preguntas para un buscador de apuntes de
|
||||||
|
pentesting. Te doy un fragmento de apuntes tecnicos. Devuelve de UNA a TRES
|
||||||
|
preguntas, en castellano, que una persona haria por voz y que ese fragmento
|
||||||
|
responde.
|
||||||
|
|
||||||
|
Reglas:
|
||||||
|
- Preguntas naturales y variadas, como las diria alguien: "como...", "que
|
||||||
|
comando...", "cual es la forma de...".
|
||||||
|
- NO respondas, NO copies comandos: solo las preguntas.
|
||||||
|
- Si el fragmento es ruido (un titulo suelto, una lista de enlaces), devuelve
|
||||||
|
una lista vacia.
|
||||||
|
|
||||||
|
Responde SOLO con JSON: {"preguntas": ["...", "..."]}"""
|
||||||
|
|
||||||
|
|
||||||
|
FIJO = os.environ.get("JARVIS_MODELO") # si se fija a mano, manda
|
||||||
|
RESPALDO = "qwen3.5:4b-jarvis"
|
||||||
|
|
||||||
|
|
||||||
|
def _modelo_cargado():
|
||||||
|
"""El modelo que ollama ya tiene en memoria, para no forzar un cambio."""
|
||||||
|
try:
|
||||||
|
with urllib.request.urlopen(ENDPOINT + "/api/ps", timeout=5) as r:
|
||||||
|
m = json.load(r).get("models", [])
|
||||||
|
if m:
|
||||||
|
return m[0]["name"]
|
||||||
|
except Exception:
|
||||||
|
pass
|
||||||
|
return None
|
||||||
|
|
||||||
|
|
||||||
|
def _modelo():
|
||||||
|
"""Que modelo usar AHORA. Se re-mira cada tanto en vez de fijarlo al
|
||||||
|
arrancar: en una tarjeta de 4 GB solo cabe uno, asi que si el carril verde
|
||||||
|
tiene el suyo cargado, generamos con ESE (una pregunta no necesita el ajuste
|
||||||
|
anti-alucinacion, solo la respuesta lo necesitaria y la respuesta es el
|
||||||
|
fragmento literal). Asi no se fuerza a ollama a cambiar de modelo en cada
|
||||||
|
peticion, que en esta maquina cuesta 2-3 s de recarga.
|
||||||
|
"""
|
||||||
|
return FIJO or _modelo_cargado() or RESPALDO
|
||||||
|
|
||||||
|
|
||||||
|
MODELO = _modelo()
|
||||||
|
|
||||||
|
|
||||||
|
def _pide(fragmento, modelo):
|
||||||
|
cuerpo = json.dumps({
|
||||||
|
"model": modelo,
|
||||||
|
"messages": [{"role": "system", "content": INSTRUCCION},
|
||||||
|
{"role": "user", "content": fragmento[:1400]}],
|
||||||
|
"stream": False, "think": False,
|
||||||
|
"options": {"temperature": 0.7, "num_predict": 200},
|
||||||
|
"format": "json",
|
||||||
|
}).encode()
|
||||||
|
req = urllib.request.Request(ENDPOINT + "/api/chat", data=cuerpo,
|
||||||
|
headers={"Content-Type": "application/json"})
|
||||||
|
try:
|
||||||
|
with urllib.request.urlopen(req, timeout=120) as r:
|
||||||
|
contenido = json.loads(r.read())["message"]["content"]
|
||||||
|
except Exception:
|
||||||
|
return []
|
||||||
|
try:
|
||||||
|
d = json.loads(contenido)
|
||||||
|
except json.JSONDecodeError:
|
||||||
|
m = re.search(r"\[.*\]", contenido, re.S)
|
||||||
|
if not m:
|
||||||
|
return []
|
||||||
|
try:
|
||||||
|
d = {"preguntas": json.loads(m.group(0))}
|
||||||
|
except json.JSONDecodeError:
|
||||||
|
return []
|
||||||
|
preguntas = d.get("preguntas") if isinstance(d, dict) else d
|
||||||
|
if not isinstance(preguntas, list):
|
||||||
|
return []
|
||||||
|
fuera = []
|
||||||
|
for p in preguntas:
|
||||||
|
if isinstance(p, str) and 8 <= len(p.strip()) <= 200:
|
||||||
|
fuera.append(p.strip())
|
||||||
|
return fuera[:3]
|
||||||
|
|
||||||
|
|
||||||
|
def fragmentos():
|
||||||
|
"""Los fragmentos de cosecha, el ORO (metodologia) primero."""
|
||||||
|
todos = []
|
||||||
|
with open(COSECHA, encoding="utf-8") as f:
|
||||||
|
for l in f:
|
||||||
|
try:
|
||||||
|
todos.append(json.loads(l))
|
||||||
|
except json.JSONDecodeError:
|
||||||
|
continue
|
||||||
|
todos.sort(key=lambda d: 0 if d.get("tipo") == "metodologia" else 1)
|
||||||
|
return todos
|
||||||
|
|
||||||
|
|
||||||
|
def main():
|
||||||
|
p = argparse.ArgumentParser()
|
||||||
|
p.add_argument("--muestra", type=int, default=0)
|
||||||
|
a = p.parse_args()
|
||||||
|
|
||||||
|
if not os.path.exists(COSECHA):
|
||||||
|
print(" no hay cosecha.jsonl: corre cosecha.py primero")
|
||||||
|
return 1
|
||||||
|
|
||||||
|
frags = fragmentos()
|
||||||
|
print(f" {len(frags)} fragmentos · modelo {MODELO}", flush=True)
|
||||||
|
|
||||||
|
if a.muestra:
|
||||||
|
for fr in frags[:a.muestra]:
|
||||||
|
print(f"\n ── {fr.get('fichero')} ──")
|
||||||
|
for q in _pide(fr["texto"], MODELO):
|
||||||
|
print(f" P: {q}")
|
||||||
|
return 0
|
||||||
|
|
||||||
|
desde = 0
|
||||||
|
if os.path.exists(MARCA) and os.path.exists(SALIDA):
|
||||||
|
try:
|
||||||
|
desde = int(open(MARCA).read().strip()) + 1
|
||||||
|
except (ValueError, OSError):
|
||||||
|
desde = 0
|
||||||
|
modo = "a" if desde else "w"
|
||||||
|
hechas = sum(1 for _ in open(SALIDA)) if desde and os.path.exists(SALIDA) else 0
|
||||||
|
if desde:
|
||||||
|
print(f" reanudando desde el fragmento {desde} ({hechas} preguntas)", flush=True)
|
||||||
|
|
||||||
|
total = len(frags)
|
||||||
|
modelo = MODELO
|
||||||
|
with open(SALIDA, modo, encoding="utf-8", buffering=1) as out:
|
||||||
|
for i in range(desde, total):
|
||||||
|
# re-mirar que modelo esta cargado cada 25: si el verde se abre o se
|
||||||
|
# cierra durante la noche, seguimos al que este en la tarjeta.
|
||||||
|
if i % 25 == 0:
|
||||||
|
modelo = _modelo()
|
||||||
|
fr = frags[i]
|
||||||
|
for q in _pide(fr["texto"], modelo):
|
||||||
|
out.write(json.dumps({
|
||||||
|
"tipo": "pregunta",
|
||||||
|
"herramienta": fr.get("herramienta"),
|
||||||
|
"perfil": fr.get("perfil"),
|
||||||
|
"fichero": fr.get("fichero"),
|
||||||
|
"tema": fr.get("tema", ""),
|
||||||
|
"texto": fr["texto"], # la respuesta: el fragmento LITERAL
|
||||||
|
"indexar": q, # lo que se embebe: la pregunta
|
||||||
|
}, ensure_ascii=False) + "\n")
|
||||||
|
hechas += 1
|
||||||
|
with open(MARCA, "w") as m:
|
||||||
|
m.write(str(i))
|
||||||
|
if (i + 1) % 25 == 0:
|
||||||
|
print(f" PROGRESO sintetiza hecho={i+1} total={total} "
|
||||||
|
f"preguntas={hechas}", flush=True)
|
||||||
|
print(f"\n hecho: {hechas} preguntas en {SALIDA}", flush=True)
|
||||||
|
return 0
|
||||||
|
|
||||||
|
|
||||||
|
if __name__ == "__main__":
|
||||||
|
sys.exit(main())
|
||||||
94
nucleo/saber/glosario.py
Normal file
94
nucleo/saber/glosario.py
Normal file
|
|
@ -0,0 +1,94 @@
|
||||||
|
"""Tareas comunes de Linux en castellano, mapeadas al comando.
|
||||||
|
|
||||||
|
El puente que las man pages no dan: estan en ingles, y "cambiar permisos" no se
|
||||||
|
parece a "change file mode bits". Aqui viven las tareas del dia a dia dichas
|
||||||
|
como las diria el usuario, con el comando y una linea de como se usa. Es
|
||||||
|
curado a mano a proposito: son las 50 cosas que de verdad se piden, y una
|
||||||
|
traduccion buena vale mas que mil man pages mal recuperadas.
|
||||||
|
|
||||||
|
Se anaden al indice como entradas normales, asi que se buscan igual que todo lo
|
||||||
|
demas y ademas se llevan el impulso por palabras exactas.
|
||||||
|
"""
|
||||||
|
|
||||||
|
# (lo que se pide en castellano, el comando, como se usa)
|
||||||
|
TAREAS = [
|
||||||
|
("cambiar los permisos de un fichero o carpeta", "chmod",
|
||||||
|
"chmod 755 fichero (rwx dueño, rx resto). chmod +x da permiso de ejecucion."),
|
||||||
|
("cambiar el dueño de un fichero", "chown",
|
||||||
|
"chown usuario:grupo fichero. Con -R para una carpeta entera."),
|
||||||
|
("comprimir una carpeta en un archivo", "tar",
|
||||||
|
"tar czf archivo.tar.gz carpeta/ comprime. tar xzf archivo.tar.gz extrae."),
|
||||||
|
("descomprimir un zip", "unzip", "unzip archivo.zip. Con -d carpeta para donde."),
|
||||||
|
("buscar texto dentro de ficheros", "grep",
|
||||||
|
"grep -r 'texto' carpeta/ busca en todo. grep -i ignora mayusculas."),
|
||||||
|
("buscar ficheros por nombre", "find",
|
||||||
|
"find /ruta -name '*.txt' busca por nombre. -type f solo ficheros."),
|
||||||
|
("ver los puertos abiertos en escucha", "ss",
|
||||||
|
"ss -tlnp lista los puertos TCP en escucha con su proceso."),
|
||||||
|
("ver que procesos consumen mas", "top",
|
||||||
|
"top o htop en tiempo real. ps aux --sort=-%cpu para una foto."),
|
||||||
|
("matar un proceso", "kill",
|
||||||
|
"kill PID lo termina. kill -9 PID a la fuerza. pkill nombre por nombre."),
|
||||||
|
("ver el espacio libre en disco", "df", "df -h muestra el espacio por particion."),
|
||||||
|
("ver cuanto ocupa una carpeta", "du", "du -sh carpeta/ el tamaño total."),
|
||||||
|
("ver la memoria libre", "free", "free -h muestra RAM y swap."),
|
||||||
|
("descargar un fichero de internet", "wget",
|
||||||
|
"wget URL descarga. curl -O URL tambien. curl -L sigue redirecciones."),
|
||||||
|
("copiar ficheros a un servidor", "scp",
|
||||||
|
"scp fichero usuario@servidor:/ruta lo sube. scp -r para carpetas."),
|
||||||
|
("sincronizar carpetas", "rsync",
|
||||||
|
"rsync -av origen/ destino/ copia solo lo cambiado. -z comprime en red."),
|
||||||
|
("editar un fichero de texto", "nano",
|
||||||
|
"nano fichero (facil) o vim fichero. Ctrl+O guarda y Ctrl+X sale en nano."),
|
||||||
|
("ver el contenido de un fichero", "cat",
|
||||||
|
"cat fichero. less fichero para leer largo. head/tail para principio/final."),
|
||||||
|
("ver los ultimos cambios de un fichero de log", "tail",
|
||||||
|
"tail -f log sigue en vivo. tail -n 50 las ultimas 50 lineas."),
|
||||||
|
("ver los servicios del sistema", "systemctl",
|
||||||
|
"systemctl status servicio. start/stop/restart para manejarlo."),
|
||||||
|
("ver los mensajes del sistema", "journalctl",
|
||||||
|
"journalctl -xe lo reciente. journalctl -u servicio de un servicio."),
|
||||||
|
("montar un disco o usb", "mount",
|
||||||
|
"mount /dev/sdX1 /mnt monta. lsblk lista los discos. umount desmonta."),
|
||||||
|
("ver la configuracion de red", "ip",
|
||||||
|
"ip a las interfaces y sus IP. ip r la tabla de rutas."),
|
||||||
|
("escanear una red o unos puertos", "nmap",
|
||||||
|
"nmap -sV objetivo detecta servicios. nmap -p- todos los puertos."),
|
||||||
|
("ver el uso de red en vivo", "iftop", "iftop o nload muestran el trafico en vivo."),
|
||||||
|
("cambiar de directorio y listar", "ls",
|
||||||
|
"ls -la lista con detalles y ocultos. cd carpeta entra. pwd dice donde estas."),
|
||||||
|
("crear una carpeta", "mkdir", "mkdir carpeta. mkdir -p a/b/c crea la ruta entera."),
|
||||||
|
("mover o renombrar", "mv", "mv origen destino mueve o renombra."),
|
||||||
|
("copiar ficheros", "cp", "cp origen destino. cp -r para carpetas."),
|
||||||
|
("borrar ficheros", "rm",
|
||||||
|
"rm fichero. rm -r carpeta. CUIDADO: no hay papelera, es definitivo."),
|
||||||
|
("dar permisos de administrador a un comando", "sudo",
|
||||||
|
"sudo comando lo ejecuta como root. Pide tu contraseña."),
|
||||||
|
("ver el historial de comandos", "history", "history lista lo tecleado. Ctrl+R busca."),
|
||||||
|
("programar una tarea periodica", "cron",
|
||||||
|
"crontab -e edita tus tareas. Formato: min hora dia mes diasemana comando."),
|
||||||
|
("ver la temperatura y el hardware", "sensors",
|
||||||
|
"sensors muestra temperaturas. lscpu la CPU, lspci los dispositivos."),
|
||||||
|
("gestionar paquetes en Debian", "apt",
|
||||||
|
"apt install paquete, apt update actualiza la lista, apt upgrade el sistema."),
|
||||||
|
("ver o cambiar variables de entorno", "export",
|
||||||
|
"export VAR=valor la pone. env las lista. echo $VAR la muestra."),
|
||||||
|
("comprobar si un comando esta instalado", "which",
|
||||||
|
"which comando dice donde esta, o nada si no esta. type comando tambien."),
|
||||||
|
("ver diferencias entre dos ficheros", "diff",
|
||||||
|
"diff a b muestra las diferencias. diff -u formato de parche."),
|
||||||
|
("contar lineas palabras o bytes", "wc",
|
||||||
|
"wc -l lineas, wc -w palabras. cat fichero | wc -l cuenta lineas."),
|
||||||
|
("conectarse a una base de datos", "psql",
|
||||||
|
"psql -U usuario base para Postgres. mysql -u usuario -p para MySQL."),
|
||||||
|
("ver quien esta conectado", "who", "who los usuarios. w con lo que hacen."),
|
||||||
|
]
|
||||||
|
|
||||||
|
|
||||||
|
def entradas():
|
||||||
|
for pide, cmd, como in TAREAS:
|
||||||
|
yield {
|
||||||
|
"tipo": "tarea", "herramienta": cmd, "perfil": "LINUX",
|
||||||
|
"fichero": f"tarea comun: {cmd}",
|
||||||
|
"texto": f"Para {pide}: usa {cmd}. {como}",
|
||||||
|
}
|
||||||
Some files were not shown because too many files have changed in this diff Show more
Loading…
Add table
Add a link
Reference in a new issue