\n"); exit(1); }
+$BAK = "/tmp/prettify_carta_bak"; if ($APPLY) @mkdir($BAK, 0777, true);
+
+$tot = 0;
+foreach (pll_get_post_translations($CARTA) as $lang => $pid) {
+ $post = get_post($pid); if (!$post) continue;
+ $chg = 0;
+ $new = preg_replace_callback('~href="([^"]*[?&]p=(\d+)[^"]*)"~i', function($m) use (&$chg) {
+ $id = (int) $m[2];
+ $url = get_permalink($id);
+ if (!$url || strpos($url, '?p=') !== false) return $m[0]; // sigue feo → dejar
+ $chg++;
+ return 'href="' . esc_url($url) . '"';
+ }, $post->post_content);
+ echo sprintf("#%d [%s] «%s» — %d enlaces ?p= → slug\n", $pid, $lang, mb_substr($post->post_title,0,28), $chg);
+ $tot += $chg;
+ if ($APPLY && $chg) {
+ file_put_contents("$BAK/$pid.html", $post->post_content);
+ wp_update_post(['ID'=>$pid, 'post_content'=>$new]);
+ clean_post_cache($pid);
+ }
+}
+// Invalida los transients de secciones de la portada para que recoja los cambios.
+if ($APPLY) {
+ global $wpdb;
+ $wpdb->query("DELETE FROM {$wpdb->options} WHERE option_name LIKE '_transient_fea_carta_sections_%'");
+ $wpdb->query("DELETE FROM {$wpdb->options} WHERE option_name LIKE '_transient_timeout_fea_carta_sections_%'");
+}
+echo ($APPLY ? "APLICADO" : "DRY-RUN") . ": $tot enlaces.\n";
diff --git a/scripts/publish_carta.php b/scripts/publish_carta.php
new file mode 100644
index 0000000..9931fc7
--- /dev/null
+++ b/scripts/publish_carta.php
@@ -0,0 +1,26 @@
+'post','numberposts'=>-1,'post_status'=>'any',
+ 'fields'=>'ids','meta_key'=>'_carta_id','meta_value'=>$CARTA]);
+$es_ids = array_merge($es_ids, $arts);
+$all = [];
+foreach ($es_ids as $id) foreach (pll_get_post_translations($id) as $tid) $all[$tid]=true;
+$all = array_keys($all);
+
+$now = current_time('mysql'); $now_gmt = current_time('mysql', true);
+$pub=0; $skip=0; $fixed=0;
+foreach ($all as $id) {
+ $p = get_post($id); if(!$p) continue;
+ if ($p->post_status === 'publish') { $skip++; continue; }
+ $data = ['ID'=>$id, 'post_status'=>'publish'];
+ if (strtotime($p->post_date_gmt) > strtotime($now_gmt)) { // fecha futura -> a ahora
+ $data['post_date']=$now; $data['post_date_gmt']=$now_gmt; $fixed++;
+ }
+ $r = wp_update_post($data, true);
+ if (is_wp_error($r)) { echo "ERR #$id: ".$r->get_error_message()."\n"; continue; }
+ clean_post_cache($id); $pub++;
+}
+echo "Publicados: $pub | ya estaban: $skip | fechas futuras corregidas: $fixed\n";
diff --git a/scripts/quitar_multimedia.php b/scripts/quitar_multimedia.php
new file mode 100644
index 0000000..7727cbf
--- /dev/null
+++ b/scripts/quitar_multimedia.php
@@ -0,0 +1,14 @@
+get_results("SELECT ID FROM {$wpdb->posts} WHERE post_type='post' AND post_status='publish' AND post_title REGEXP '[0-9]+, *[0-9]+(-[0-9]+)?\\.?$'");
+$feadulta=(int)$wpdb->get_var("SELECT term_id FROM {$wpdb->terms} WHERE name='Feadulta' LIMIT 1");
+$changed=0;
+foreach($rows as $r){
+ $cats=wp_get_post_categories($r->ID);
+ $new=array_values(array_diff($cats,$multi));
+ if(count($new)!==count($cats)){ if(!$new)$new=[$feadulta]; wp_set_post_categories($r->ID,$new); $changed++; }
+}
+echo "lecturas con Multimedia eliminada: $changed\n";
diff --git a/scripts/reasign_cats.php b/scripts/reasign_cats.php
new file mode 100644
index 0000000..a5f0e41
--- /dev/null
+++ b/scripts/reasign_cats.php
@@ -0,0 +1,70 @@
+ term_id
+
+function translate_or_mirror($c, $lang, &$cache) {
+ $key = $c . '|' . $lang;
+ if (isset($cache[$key])) return $cache[$key];
+ $t = pll_get_term($c, $lang);
+ if (!$t) {
+ $term = get_term($c, 'category');
+ if (!$term || is_wp_error($term)) { return $cache[$key] = $c; }
+ $slug = sanitize_title($term->name) . '-' . $lang . '-' . $c;
+ $res = wp_insert_term($term->name, 'category', ['slug' => $slug]);
+ if (is_wp_error($res)) {
+ $ex = $res->get_error_data();
+ if (!$ex) { return $cache[$key] = $c; }
+ $t = is_array($ex) ? ($ex['term_id'] ?? 0) : (int) $ex;
+ } else {
+ $t = $res['term_id'];
+ }
+ if ($t) {
+ pll_set_term_language($t, $lang);
+ $tr = pll_get_term_translations($c);
+ $tr[$lang] = $t;
+ pll_save_term_translations($tr);
+ } else {
+ $t = $c;
+ }
+ }
+ return $cache[$key] = (int) $t;
+}
+
+$langs = $only_lang ? [$only_lang] : ['en','fr','it','pt'];
+$done = 0; $changed = 0; $mirrors = 0;
+$start_mirror_terms = count($mirror_cache);
+foreach ($langs as $lang) {
+ $args = ['lang'=>$lang,'post_type'=>'post','post_status'=>['publish','draft'],
+ 'fields'=>'ids','posts_per_page'=> $limit ?: -1,'no_found_rows'=>true,
+ 'meta_query'=>[['key'=>'_cats_reasignadas','compare'=>'NOT EXISTS']]];
+ $ids = get_posts($args);
+ foreach ($ids as $pid) {
+ // Fuente de verdad = categorías del ES original (las del post traducido
+ // pueden estar incompletas). Se traducen al idioma del post.
+ $es = pll_get_post($pid, 'es');
+ $source = ($es && $es != $pid) ? wp_get_post_categories($es) : wp_get_post_categories($pid);
+ $new = [];
+ foreach ($source as $c) {
+ $clang = pll_get_term_language($c);
+ $new[] = ($clang === $lang) ? $c : translate_or_mirror($c, $lang, $mirror_cache);
+ }
+ $new = array_values(array_unique($new));
+ $cur = wp_get_post_categories($pid);
+ sort($cur); $cmp = $new; sort($cmp);
+ if ($cur !== $cmp && $new) { wp_set_post_categories($pid, $new); $changed++; }
+ update_post_meta($pid, '_cats_reasignadas', 1);
+ $done++;
+ }
+}
+echo "procesados: $done | con cambios: $changed | términos espejo en caché: " . count($mirror_cache) . "\n";
diff --git a/scripts/regen_avatars.php b/scripts/regen_avatars.php
new file mode 100644
index 0000000..32b9827
--- /dev/null
+++ b/scripts/regen_avatars.php
@@ -0,0 +1,40 @@
+get_results(
+ "SELECT ID FROM {$wpdb->posts}
+ WHERE post_type='attachment'
+ AND guid LIKE '%/autores/joomla/%'"
+);
+echo 'Attachments: ' . count($rows) . PHP_EOL;
+
+$uploads_basedir = wp_upload_dir()['basedir'];
+$ok = 0; $fail = 0;
+foreach ($rows as $r) {
+ $aid = (int) $r->ID;
+ $file = get_attached_file($aid);
+ if (!$file || !file_exists($file)) { $fail++; continue; }
+
+ // Borrar thumbnails viejos del attachment (todas las variantes -WxH)
+ $old_meta = wp_get_attachment_metadata($aid);
+ if (!empty($old_meta['sizes'])) {
+ $dir = dirname($file);
+ foreach ($old_meta['sizes'] as $s) {
+ $thumb = $dir . '/' . $s['file'];
+ if (file_exists($thumb)) @unlink($thumb);
+ }
+ }
+ // Regenerar
+ $meta = wp_generate_attachment_metadata($aid, $file);
+ if ($meta) {
+ wp_update_attachment_metadata($aid, $meta);
+ $ok++;
+ } else {
+ $fail++;
+ }
+}
+echo "OK: $ok, FAIL: $fail" . PHP_EOL;
diff --git a/scripts/regenerar_clasificacion_csv.py b/scripts/regenerar_clasificacion_csv.py
new file mode 100644
index 0000000..3426a61
--- /dev/null
+++ b/scripts/regenerar_clasificacion_csv.py
@@ -0,0 +1,298 @@
+#!/usr/bin/env python3
+"""
+Regenera `clasificacion_articulos.csv` recorriendo las cartas semanales y
+extrayendo los links que cada una agrupa por encabezado (Artículos, Evangelio,
+Eucaristía, Multimedia, EFFA). Paridad con `wp-content/mu-plugins/fea-carta-portada.php`.
+
+Output: post_id, post_title, categoria_propuesta, seccion_original, carta_id, carta_titulo, carta_fecha
+
+ALCANCE (vs. CSV histórico de marzo 2026):
+- Cubre las 5 secciones estándar: comentario, articulo, eucaristia, multimedia, effa.
+- Sub-clasifica por posición dentro de "Evangelio y comentarios al Evangelio":
+ · pos 1 → `lectura` (cita del evangelio)
+ · pos 2 → `comentario_editorial`
+ · pos 3+ → `comentario`
+ (regla del editor, confirmada contra el CSV histórico)
+- NO cubre todavía:
+ · `lectura` dentro de eucaristía (lecturas bíblicas — el viejo las separa, aquí van todas a `eucaristia`)
+ · `otro` (catch-all del catch-all)
+ · `noticia` (subgrupo poco usado, 12 filas en el viejo)
+ · Encabezados de fiestas especiales ("Domingo de Resurrección", "Navidad", "Vigilia Pascual", etc.)
+
+Para regenerar el CSV con cobertura completa habría que ampliar el mapping en
+SECTION_PATTERNS y SECTION_LABELS con reglas adicionales. El CSV histórico
+existente (raíz del repo) sirve como baseline para esa cobertura granular.
+
+Uso:
+ python3 regenerar_clasificacion_csv.py [--out /path/clasificacion_articulos.csv] [--diff /path/csv_marzo.csv]
+
+Issue: rafa/feadulta#42
+"""
+import argparse, csv, os, re, subprocess, sys
+
+try:
+ import pymysql
+except ImportError:
+ sys.exit('pymysql requerido: pip install --user pymysql')
+
+# Mapping sección encabezado → cat slug (debe espejar fea-carta-portada.php)
+SECTION_PATTERNS = [
+ ('comentario', re.compile(r'Evangelio\s+y\s+comentarios\s+al\s+Evangelio', re.I)),
+ ('articulo', re.compile(r'Art[ií]culos\s+seleccionados\s+para\s+la\s+semana', re.I)),
+ ('eucaristia', re.compile(r'Para\s+unas\s+eucarist[ií]as\s+m[áa]s\s+participativas', re.I)),
+ ('multimedia', re.compile(r'Material\s+multimedia', re.I)),
+ ('effa', re.compile(r'Escuela\s+EFFA', re.I)),
+]
+
+# Nombres “bonitos” usados en seccion_original (verbatim del CSV histórico)
+SECTION_LABELS = {
+ 'comentario': 'Evangelio y comentarios al Evangelio',
+ 'articulo': 'Artículos seleccionados para la semana',
+ 'eucaristia': 'Para unas eucaristías más participativas y actuales',
+ 'multimedia': 'Material multimedia',
+ 'effa': 'Escuela EFFA',
+}
+
+CAT_PROPUESTA = {
+ 'comentario': 'comentario',
+ 'articulo': 'articulo',
+ 'eucaristia': 'eucaristia',
+ 'multimedia': 'multimedia',
+ 'effa': 'effa',
+}
+
+# Sub-clasificación posicional dentro de la sección "Evangelio y comentarios al Evangelio".
+# El editor SIEMPRE coloca: 1º lectura del evangelio, 2º comentario editorial, 3º+ comentarios.
+SUBCAT_EVANGELIO_BY_POS = ['lectura', 'comentario_editorial'] # resto = 'comentario'
+
+HREF_RX = re.compile(r'href=["\']([^"\']+)["\']', re.I)
+WP_SLUG_RX = re.compile(r'(?:^|/)fea/([a-z0-9\-]+)/?(?:[?#]|$)', re.I)
+K2_ITEM_RX = re.compile(r'/item/(\d+)-[^/"]+\.html', re.I)
+RESERVED_SLUGS = {'wp-admin','wp-content','category','tag','author','page','en','fr','it','pt'}
+
+
+def get_conn():
+ ip = subprocess.run(
+ ['docker', 'inspect', 'wordpress-mysql', '--format',
+ '{{range .NetworkSettings.Networks}}{{.IPAddress}}{{end}}'],
+ capture_output=True, text=True, check=True,
+ ).stdout.strip()
+ return pymysql.connect(
+ host=ip, user='wordpress_user', password='wordpress_pass',
+ database='wordpress_db', charset='utf8mb4', autocommit=True,
+ )
+
+
+def mysql(query, conn=None):
+ """Ejecuta query y devuelve filas (lista de tuplas) — pymysql, sin parsing CLI."""
+ own = False
+ if conn is None:
+ conn = get_conn(); own = True
+ try:
+ with conn.cursor() as c:
+ c.execute(query)
+ return list(c.fetchall())
+ finally:
+ if own: conn.close()
+
+
+def fetch_cartas(conn):
+ """Todas las cartas (cat 6 actual, 22 semana pasada, 21 otras) + sus contenidos."""
+ q = """
+ SELECT p.ID, p.post_title, DATE(p.post_date), p.post_content
+ FROM wp_posts p
+ WHERE p.post_status='publish' AND p.post_type='post'
+ AND p.ID IN (
+ SELECT DISTINCT tr.object_id FROM wp_term_relationships tr
+ JOIN wp_term_taxonomy tt ON tt.term_taxonomy_id=tr.term_taxonomy_id
+ WHERE tt.term_id IN (6, 21, 22) AND tt.taxonomy='category'
+ )
+ ORDER BY p.post_date DESC;
+ """
+ return mysql(q, conn)
+
+
+def build_lookups(conn):
+ """Construye dicts slug→post_id y k2_id→post_id para no machacar la BD por cada link.
+ Para slugs duplicados (varios posts con mismo slug), se usa el MÁS RECIENTE
+ (criterio espejo del mu-plugin fea-carta-portada.php tras el bug detectado en #38).
+ """
+ print('Cargando lookups (slug y k2_id) ...', file=sys.stderr, flush=True)
+ slug_to_id = {}
+ rows = mysql("""
+ SELECT p1.post_name, p1.ID
+ FROM wp_posts p1
+ WHERE p1.post_status='publish' AND p1.post_type='post' AND p1.post_name<>''
+ ORDER BY p1.post_date DESC;
+ """, conn)
+ for r in rows:
+ slug = r[0]
+ if slug not in slug_to_id: # primero (más reciente) gana
+ slug_to_id[slug] = int(r[1])
+
+ k2_to_id = {}
+ rows = mysql("""
+ SELECT meta_value, MAX(post_id) FROM wp_postmeta
+ WHERE meta_key='_fgj2wp_old_k2_id' AND meta_value<>''
+ GROUP BY meta_value;
+ """, conn)
+ for r in rows:
+ try:
+ k2_to_id[int(r[0])] = int(r[1])
+ except (ValueError, TypeError):
+ continue
+
+ print(f' slugs: {len(slug_to_id)} k2_ids: {len(k2_to_id)}', file=sys.stderr)
+ return slug_to_id, k2_to_id
+
+
+def fetch_titles(ids, conn):
+ if not ids: return {}
+ ids_str = ','.join(str(i) for i in ids)
+ rows = mysql(f"SELECT ID, post_title FROM wp_posts WHERE ID IN ({ids_str});", conn)
+ return {int(r[0]): r[1] for r in rows}
+
+
+def url_to_post_id(url, slug_to_id, k2_to_id):
+ m = WP_SLUG_RX.search(url)
+ if m:
+ slug = m.group(1).lower()
+ if slug not in RESERVED_SLUGS and slug in slug_to_id:
+ return slug_to_id[slug]
+ m = K2_ITEM_RX.search(url)
+ if m:
+ k2 = int(m.group(1))
+ if k2 in k2_to_id:
+ return k2_to_id[k2]
+ return None
+
+
+def extract_sections(html_content):
+ """Devuelve dict {section_slug: [post_id, ...]} basándose en encabezados.
+ NOTA: los post_ids aún no están resueltos aquí — devuelve hrefs en su lugar.
+ """
+ positions = []
+ for slug, rx in SECTION_PATTERNS:
+ m = rx.search(html_content)
+ if m:
+ positions.append((m.start(), slug))
+ if not positions:
+ return {}
+ positions.sort()
+ positions.append((len(html_content), None))
+
+ out = {}
+ for i in range(len(positions) - 1):
+ start, slug = positions[i]
+ end = positions[i+1][0]
+ segment = html_content[start:end]
+ hrefs = HREF_RX.findall(segment)
+ # Dedup preservando orden
+ seen, urls = set(), []
+ for h in hrefs:
+ if h not in seen:
+ seen.add(h); urls.append(h)
+ out[slug] = urls
+ return out
+
+
+def main():
+ ap = argparse.ArgumentParser()
+ ap.add_argument('--out', default='/tmp/clasificacion_articulos_regen.csv')
+ ap.add_argument('--diff', help='CSV de referencia para mostrar diff')
+ args = ap.parse_args()
+
+ conn = get_conn()
+ slug_to_id, k2_to_id = build_lookups(conn)
+
+ print('Leyendo cartas ...', file=sys.stderr, flush=True)
+ cartas = fetch_cartas(conn)
+ print(f' cartas: {len(cartas)}', file=sys.stderr)
+
+ rows_out = []
+ needed_titles = set()
+ n_unresolved = 0
+ n_resolved = 0
+
+ for c in cartas:
+ carta_id, carta_title, carta_fecha, content = c
+ carta_id = int(carta_id)
+ if not content:
+ continue
+
+ sections = extract_sections(content)
+ for slug, urls in sections.items():
+ label = SECTION_LABELS[slug]
+ default_cat = CAT_PROPUESTA[slug]
+ # Filtrar a posts resueltos manteniendo orden
+ resolved = []
+ for url in urls:
+ pid = url_to_post_id(url, slug_to_id, k2_to_id)
+ if pid is None:
+ n_unresolved += 1
+ continue
+ resolved.append(pid)
+ for pos, pid in enumerate(resolved):
+ # Sub-clasificación posicional para evangelio
+ if slug == 'comentario' and pos < len(SUBCAT_EVANGELIO_BY_POS):
+ cat = SUBCAT_EVANGELIO_BY_POS[pos]
+ else:
+ cat = default_cat
+ n_resolved += 1
+ needed_titles.add(pid)
+ rows_out.append({
+ 'post_id': pid,
+ 'categoria_propuesta': cat,
+ 'seccion_original': label,
+ 'carta_id': carta_id,
+ 'carta_titulo': carta_title,
+ 'carta_fecha': carta_fecha,
+ })
+
+ print(f'Resueltos: {n_resolved} Sin resolver: {n_unresolved}', file=sys.stderr)
+ print('Cargando títulos ...', file=sys.stderr, flush=True)
+ titles = fetch_titles(list(needed_titles), conn)
+ conn.close()
+
+ # Escribir CSV
+ cols = ['post_id', 'post_title', 'categoria_propuesta', 'seccion_original', 'carta_id', 'carta_titulo', 'carta_fecha']
+ with open(args.out, 'w', newline='', encoding='utf-8') as f:
+ w = csv.DictWriter(f, fieldnames=cols, quoting=csv.QUOTE_MINIMAL)
+ w.writeheader()
+ for r in rows_out:
+ r['post_title'] = titles.get(r['post_id'], '')
+ w.writerow(r)
+ print(f'Escrito: {args.out} ({len(rows_out)} filas)')
+
+ # Diff opcional
+ if args.diff and os.path.exists(args.diff):
+ from collections import defaultdict, Counter
+ def load(path):
+ d = defaultdict(set) # (post_id, cat) → set((carta_id, seccion))
+ cats_by_post = defaultdict(set)
+ with open(path, encoding='utf-8-sig') as fh:
+ r = csv.DictReader(fh)
+ for row in r:
+ pid = row.get('post_id','')
+ cat = row.get('categoria_propuesta','')
+ if not pid: continue
+ cats_by_post[pid].add(cat)
+ return cats_by_post
+ old = load(args.diff)
+ new = load(args.out)
+ old_keys = set(old.keys())
+ new_keys = set(new.keys())
+ print('\n=== DIFF ===')
+ print(f'posts en CSV viejo: {len(old_keys)}')
+ print(f'posts en CSV nuevo: {len(new_keys)}')
+ print(f'solo en viejo: {len(old_keys - new_keys)}')
+ print(f'solo en nuevo: {len(new_keys - old_keys)}')
+ common = old_keys & new_keys
+ same_cats = sum(1 for k in common if old[k] == new[k])
+ diff_cats = len(common) - same_cats
+ print(f'común con mismas cats: {same_cats}')
+ print(f'común con cats distintas: {diff_cats}')
+
+
+if __name__ == '__main__':
+ main()
diff --git a/scripts/remap_carta_tr_links.php b/scripts/remap_carta_tr_links.php
new file mode 100644
index 0000000..abdafa2
--- /dev/null
+++ b/scripts/remap_carta_tr_links.php
@@ -0,0 +1,40 @@
+$pid){
+ if($lang === 'es') continue; // la ES ya está bien
+ $post = get_post($pid); if(!$post) continue;
+ $chg=0; $miss=[];
+ $new = preg_replace_callback('~href="([^"]+)"~i', function($m) use($lang,&$chg,&$miss){
+ $href = html_entity_decode(trim($m[1]));
+ if(stripos($href,'farmer.taild3aaf6.ts.net')===false && stripos($href,'/fea/')===false) return $m[0];
+ $es = 0;
+ if(preg_match('~[?&]p=(\d+)~',$href,$mm)) $es=(int)$mm[1]; // forma ?p=ID
+ if(!$es) $es = (int)url_to_postid($href); // forma /slug/
+ if(!$es){ return $m[0]; }
+ if(pll_get_post_language($es) !== 'es'){ return $m[0]; } // solo si apunta a ES
+ $t = pll_get_post($es,$lang);
+ if(!$t || $t==$es){ $miss[]=$href; return $m[0]; } // sin traducción → dejar
+ $url = get_permalink($t);
+ if(!$url) return $m[0];
+ $chg++;
+ return 'href="'.esc_url($url).'"';
+ }, $post->post_content);
+ echo sprintf("#%d [%s] «%s» — %d remapeados%s\n",$pid,$lang,mb_substr($post->post_title,0,30),$chg,
+ $miss?(" | sin traducción: ".count($miss)):"");
+ $tot+=$chg;
+ if($APPLY && $chg){ file_put_contents("$BAK/$pid.html",$post->post_content);
+ $wpdb->update($wpdb->posts,['post_content'=>$new],['ID'=>$pid]); clean_post_cache($pid); }
+}
+echo ($APPLY?"APLICADO":"DRY-RUN").": $tot enlaces.\n";
diff --git a/scripts/remap_translation_cats.php b/scripts/remap_translation_cats.php
new file mode 100644
index 0000000..cc6f544
--- /dev/null
+++ b/scripts/remap_translation_cats.php
@@ -0,0 +1,42 @@
+get_col("SELECT DISTINCT post_id FROM {$wpdb->postmeta} WHERE meta_key='traduccion_origen'");
+$fixed = 0;
+
+foreach ($ids as $pid) {
+ $pid = (int) $pid;
+ $lang = pll_get_post_language($pid);
+ if (!$lang || $lang === 'es') continue;
+
+ $cats = wp_get_post_categories($pid);
+ $mapped = [];
+ $changed = false;
+ foreach ($cats as $c) {
+ $tc = (int) pll_get_term($c, $lang);
+ if ($tc && $tc !== $c) { $mapped[] = $tc; $changed = true; }
+ else { $mapped[] = $c; }
+ }
+ if ($changed) {
+ wp_set_post_categories($pid, array_values(array_unique($mapped)));
+ $fixed++;
+ }
+}
+
+echo "Remapeadas categorías en $fixed traducciones (de " . count($ids) . " revisadas)\n";
diff --git a/scripts/repoint_carta_links.php b/scripts/repoint_carta_links.php
new file mode 100644
index 0000000..0b542ab
--- /dev/null
+++ b/scripts/repoint_carta_links.php
@@ -0,0 +1,41 @@
+ID : 0;
+}
+
+foreach (array_values(pll_get_post_translations($CARTA)) as $pid) {
+ $post=get_post($pid); if(!$post) continue;
+ $lang=pll_get_post_language($pid) ?: 'es';
+ $chg=0;
+ $new=preg_replace_callback('~href="([^"]+)"~i', function($m) use($lang,&$chg){
+ $href=$m[1];
+ if (stripos($href,'.html')!==false) return $m[0]; // legacy lo maneja el otro script
+ $tid=resolve_post($href);
+ if(!$tid) return $m[0];
+ $plang=pll_get_post_language($tid);
+ if(!$plang || $plang===$lang) return $m[0]; // ya está en el idioma correcto
+ $t=pll_get_post($tid,$lang);
+ if(!$t || $t==$tid) return $m[0]; // no hay traducción -> dejar
+ $url=get_permalink($t); if(!$url) return $m[0];
+ $chg++; return 'href="'.esc_url($url).'"';
+ }, $post->post_content);
+ echo "#$pid [$lang] — $chg repuntado(s)\n";
+ if($APPLY && $chg){ file_put_contents("$BAK/$pid.html",$post->post_content);
+ $wpdb->update($wpdb->posts,['post_content'=>$new],['ID'=>$pid]); clean_post_cache($pid); }
+}
+echo $APPLY?"APLICADO\n":"DRY-RUN\n";
diff --git a/scripts/reprocess_en_haiku.py b/scripts/reprocess_en_haiku.py
new file mode 100644
index 0000000..fca1a11
--- /dev/null
+++ b/scripts/reprocess_en_haiku.py
@@ -0,0 +1,128 @@
+#!/usr/bin/env python3
+"""Reprocesa traducciones ROTAS con Claude Haiku 4.5 (API directa).
+
+Coge el ES original, lo traduce con Haiku y SOBRESCRIBE la traducción ya
+existente (in-place, sin duplicar). Detecta los rotos por ratio de longitud.
+
+Uso:
+ reprocess_en_haiku.py --auto --langs en --limit 100 # EN rotos
+ reprocess_en_haiku.py --auto --langs fr,it,pt --limit 50 # otros idiomas
+ reprocess_en_haiku.py --ids 44205 --langs en # src concretos
+ añade --apply para ESCRIBIR en la BD (sin él = dry-run).
+"""
+import argparse
+import json
+import os
+import re
+import subprocess
+import sys
+
+sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
+from translate_haiku import translate # noqa: E402
+
+STATE = "/tmp/feadulta-translate-state.json"
+CONTAINER = "wordpress-web"
+RATIO_BROKEN = 0.45
+
+
+def dexec(args):
+ return subprocess.run(["docker", "exec", CONTAINER, *args],
+ capture_output=True, text=True)
+
+
+def dcp(remote, local):
+ subprocess.run(["docker", "cp", f"{CONTAINER}:{remote}", local], check=True)
+
+
+def dcp_to(local, remote):
+ subprocess.run(["docker", "cp", local, f"{CONTAINER}:{remote}"], check=True)
+
+
+def get_post(pid):
+ r = dexec(["php", "/tmp/fea_post_io.php", "get", str(pid)])
+ if r.returncode != 0:
+ raise RuntimeError(f"get {pid}: {r.stderr.strip()}")
+ dcp("/tmp/fea_es.json", "/tmp/fea_es.json")
+ return json.load(open("/tmp/fea_es.json"))
+
+
+def strip_len(html):
+ return len(re.sub(r"<[^>]*>", "", html))
+
+
+def find_broken(state, langs, limit):
+ """Devuelve [(src, lang), ...] de traducciones rotas."""
+ out = []
+ for key, tid in state["done"].items():
+ src, lang = key.split(":")
+ if lang not in langs:
+ continue
+ try:
+ es = get_post(int(src))
+ tr = get_post(int(tid))
+ except RuntimeError:
+ continue
+ olen = strip_len(es["content"])
+ if olen < 40:
+ continue
+ if strip_len(tr["content"]) / olen < RATIO_BROKEN:
+ out.append((int(src), lang))
+ if len(out) >= limit:
+ break
+ return out
+
+
+def main():
+ ap = argparse.ArgumentParser()
+ ap.add_argument("--ids", nargs="*", type=int, default=[])
+ ap.add_argument("--langs", default="en")
+ ap.add_argument("--auto", action="store_true")
+ ap.add_argument("--limit", type=int, default=100)
+ ap.add_argument("--apply", action="store_true")
+ args = ap.parse_args()
+
+ langs = [l.strip() for l in args.langs.split(",") if l.strip()]
+ state = json.load(open(STATE))
+
+ if args.auto:
+ print(f"Autodetectando rotos (ratio<{RATIO_BROKEN}) en {langs}…")
+ pairs = find_broken(state, langs, args.limit)
+ print(f"Encontrados: {pairs}")
+ else:
+ pairs = [(src, lang) for src in args.ids for lang in langs]
+
+ tot_in = tot_out = 0.0
+ for src, lang in pairs:
+ tid = state["done"].get(f"{src}:{lang}")
+ if not tid:
+ print(f"[{src}:{lang}] sin traducción en state; salto")
+ continue
+ es = get_post(src)
+ body, u1 = translate(es["content"], lang)
+ title, u2 = translate(es["title"], lang, is_title=True)
+ tot_in += u1.input_tokens + u2.input_tokens
+ tot_out += u1.output_tokens + u2.output_tokens
+
+ print(f"\n===== src #{src} [{lang}] -> #{tid} =====")
+ print(f"TÍTULO {lang}: {title}")
+ print(f"cuerpo ES={strip_len(es['content'])} -> {lang}={strip_len(body)}")
+
+ if args.apply:
+ open("/tmp/fea_title.txt", "w").write(title)
+ open("/tmp/fea_body.txt", "w").write(body)
+ dcp_to("/tmp/fea_title.txt", "/tmp/fea_title.txt")
+ dcp_to("/tmp/fea_body.txt", "/tmp/fea_body.txt")
+ r = dexec(["php", "/tmp/fea_post_io.php", "update", str(tid),
+ "/tmp/fea_title.txt", "/tmp/fea_body.txt"])
+ print(("APLICADO: " + r.stdout.strip()) if r.returncode == 0
+ else ("FALLO: " + r.stderr.strip()))
+ else:
+ print("(dry-run)")
+
+ cost = tot_in / 1e6 * 1.0 + tot_out / 1e6 * 5.0
+ print(f"\nTOTAL tokens: in={int(tot_in)} out={int(tot_out)} coste=${cost:.4f}")
+ print("MODO: " + ("APLICADO a BD" if args.apply else "DRY-RUN"))
+
+
+if __name__ == "__main__":
+ main()
diff --git a/scripts/retranslate_chunks.py b/scripts/retranslate_chunks.py
new file mode 100644
index 0000000..6654daa
--- /dev/null
+++ b/scripts/retranslate_chunks.py
@@ -0,0 +1,310 @@
+#!/usr/bin/env python3
+"""
+retranslate_chunks.py
+
+Re-translates posts where content is in the wrong language.
+Splits post_content into chunks of ~800 chars (at boundaries)
+and translates each chunk independently to avoid model drift.
+"""
+
+import pymysql
+import json
+import re
+import html
+import urllib.request
+import time
+import sys
+import csv
+from langdetect import detect, LangDetectException, DetectorFactory
+DetectorFactory.seed = 0
+
+JAN_URL = "http://172.19.128.1:1337/v1/chat/completions"
+JAN_MODEL = "gemma-3-12b-it-Q4_K_M"
+
+DB = dict(host='172.18.0.2', port=3306, user='wordpress_user',
+ password='wordpress_pass', database='wordpress_db', charset='utf8mb4',
+ cursorclass=pymysql.cursors.DictCursor)
+
+LANG_NAMES = {"en": "English", "fr": "French", "it": "Italian", "pt": "Portuguese"}
+LANG_NORM = {'es':'es','pt':'pt','fr':'fr','en':'en','it':'it','ca':'es','gl':'es'}
+
+AI_FOOTER = "\nTraducido con IA
"
+CHUNK_SIZE = 800 # max chars per translation chunk
+MAX_RETRIES = 2
+
+
+def strip_html(text):
+ if not text: return ''
+ text = re.sub(r'<[^>]+>', ' ', text)
+ text = html.unescape(text)
+ return re.sub(r'\s+', ' ', text).strip()
+
+
+def detect_lang(text, min_len=60):
+ t = strip_html(text)[:600].strip()
+ if len(t) < min_len: return None
+ try: return LANG_NORM.get(detect(t), detect(t))
+ except: return None
+
+
+def call_jan(messages, max_tokens=1200, temperature=0.2, timeout=120):
+ payload = json.dumps({
+ "model": JAN_MODEL,
+ "messages": messages,
+ "temperature": temperature,
+ "max_tokens": max_tokens,
+ }).encode("utf-8")
+ req = urllib.request.Request(
+ JAN_URL, data=payload,
+ headers={"Content-Type": "application/json", "Authorization": "Bearer dummy"},
+ method="POST"
+ )
+ with urllib.request.urlopen(req, timeout=timeout) as r:
+ result = json.loads(r.read())
+ return result["choices"][0]["message"]["content"].strip()
+
+
+def translate_chunk(chunk, lang_name):
+ """Translate a single HTML chunk. Returns translated text or None on failure."""
+ system = (
+ f"You are a professional translator. Translate the following Spanish text to {lang_name}. "
+ f"Preserve all HTML tags exactly as they are. "
+ f"Return ONLY the translated text, nothing else. No preamble, no explanation."
+ )
+ plain_len = len(strip_html(chunk).strip())
+ for attempt in range(MAX_RETRIES):
+ try:
+ result = call_jan([
+ {"role": "system", "content": system},
+ {"role": "user", "content": chunk}
+ ])
+ # For short chunks (headings, short phrases) langdetect is unreliable —
+ # accept the result as long as it changed from the original Spanish
+ if plain_len < 40:
+ changed = strip_html(result).strip().lower() != strip_html(chunk).strip().lower()
+ if changed or attempt > 0:
+ return result
+ else:
+ lang = detect_lang(result, min_len=40)
+ if lang is None or lang == lang_name[:2].lower():
+ return result
+ # Wrong language — retry with more explicit prompt
+ system = (
+ f"Translate from Spanish to {lang_name}. "
+ f"Your response must be entirely in {lang_name}. "
+ f"Preserve HTML tags. Return ONLY the translation."
+ )
+ except Exception as e:
+ if attempt == MAX_RETRIES - 1:
+ return None
+ time.sleep(2)
+ return None # all retries failed
+
+
+def translate_title(title, lang_name):
+ try:
+ result = call_jan([
+ {"role": "system", "content": "You are a translator. Respond ONLY with the translated text, nothing else."},
+ {"role": "user", "content": f"Translate from Spanish to {lang_name}, ALL CAPS:\n\n{title}"}
+ ], max_tokens=120, temperature=0.1, timeout=30)
+ return result.strip().strip('"').strip("'")
+ except:
+ return None
+
+
+def split_into_chunks(content, max_size=CHUNK_SIZE):
+ """Split HTML content at boundaries into chunks <= max_size chars."""
+ # Split at closing block tags
+ parts = re.split(r'(|||)', content)
+
+ chunks = []
+ current = ""
+ for i in range(0, len(parts), 2):
+ piece = parts[i]
+ closer = parts[i+1] if i+1 < len(parts) else ""
+ segment = piece + closer
+
+ if len(current) + len(segment) <= max_size:
+ current += segment
+ else:
+ if current:
+ chunks.append(current)
+ # If a single segment exceeds max_size, split it roughly
+ if len(segment) > max_size:
+ # Split at sentence boundaries
+ sentences = re.split(r'(?<=[.!?])\s+', segment)
+ current = ""
+ for s in sentences:
+ if len(current) + len(s) <= max_size:
+ current += s + " "
+ else:
+ if current:
+ chunks.append(current.strip())
+ current = s + " "
+ else:
+ current = segment
+
+ if current:
+ chunks.append(current)
+
+ return [c for c in chunks if c.strip()]
+
+
+def translate_content_chunked(content, lang_name):
+ """
+ Translate full post_content by splitting into chunks.
+ Returns (translated_content, success_ratio).
+ """
+ if not content or not content.strip():
+ return content, 1.0
+
+ chunks = split_into_chunks(content)
+ translated_chunks = []
+ failed = 0
+
+ for chunk in chunks:
+ # Skip chunks that are only HTML tags / whitespace
+ if not strip_html(chunk).strip():
+ translated_chunks.append(chunk)
+ continue
+
+ result = translate_chunk(chunk, lang_name)
+ if result is None:
+ # Keep original chunk rather than losing it
+ translated_chunks.append(chunk)
+ failed += 1
+ else:
+ translated_chunks.append(result)
+
+ success_ratio = 1.0 - (failed / len(chunks)) if chunks else 1.0
+ return "\n".join(translated_chunks), success_ratio
+
+
+def main():
+ audit_path = '/tmp/audit_clean.csv'
+ failed_ids = set()
+ try:
+ with open(audit_path) as f:
+ reader = csv.DictReader(f)
+ for row in reader:
+ failed_ids.add(int(row['id']))
+ print(f"Loaded {len(failed_ids)} post IDs with issues from audit")
+ except FileNotFoundError:
+ print(f"ERROR: {audit_path} not found. Run audit_translations.py first.")
+ sys.exit(1)
+
+ db = pymysql.connect(**DB)
+ c = db.cursor()
+
+ id_list = ','.join(str(i) for i in sorted(failed_ids))
+ c.execute(f"""
+ SELECT DISTINCT p.ID, p.post_title, p.post_content,
+ t_lang.slug as lang,
+ ttg.description as group_desc
+ FROM wp_posts p
+ JOIN wp_term_relationships trl ON p.ID=trl.object_id
+ JOIN wp_term_taxonomy ttl ON trl.term_taxonomy_id=ttl.term_taxonomy_id AND ttl.taxonomy='language'
+ JOIN wp_terms t_lang ON ttl.term_id=t_lang.term_id
+ JOIN wp_term_relationships trg ON p.ID=trg.object_id
+ JOIN wp_term_taxonomy ttg ON trg.term_taxonomy_id=ttg.term_taxonomy_id AND ttg.taxonomy='post_translations'
+ WHERE p.ID IN ({id_list}) AND p.post_type='post' AND p.post_status='publish'
+ """)
+ raw_posts = c.fetchall()
+
+ # Fetch Spanish originals
+ posts = []
+ es_cache = {}
+ for p in raw_posts:
+ desc = p['group_desc'] or ''
+ m = re.search(r's:2:"es";i:(\d+);', desc)
+ if not m:
+ continue
+ es_id = int(m.group(1))
+ if es_id not in es_cache:
+ c.execute("SELECT ID, post_title, post_content FROM wp_posts WHERE ID=%s", (es_id,))
+ row = c.fetchone()
+ es_cache[es_id] = row
+ es = es_cache[es_id]
+ if es:
+ posts.append({**p, 'es_id': es_id, 'es_title': es['post_title'], 'es_content': es['post_content']})
+ db.close()
+ print(f"Fetched {len(posts)} posts to retranslate\n")
+
+ by_es = {}
+ for p in posts:
+ by_es.setdefault(p['es_id'], []).append(p)
+
+ done = errors = skipped = partial = 0
+ total = len(posts)
+ n = 0
+
+ for es_id, translations in sorted(by_es.items()):
+ es_title = translations[0]['es_title'] or ''
+ es_content = translations[0]['es_content'] or ''
+ content_len = len(strip_html(es_content))
+
+ if content_len < 50:
+ print(f" ES:{es_id} — SKIPPING (too short: {content_len} chars)")
+ skipped += len(translations)
+ n += len(translations)
+ continue
+
+ # Show chunk count for visibility
+ chunks = split_into_chunks(es_content)
+ print(f"\nES:{es_id} — {es_title[:50]} ({content_len} chars, {len(chunks)} chunks)")
+
+ for p in translations:
+ post_id = p['ID']
+ lang = p['lang']
+ lang_name = LANG_NAMES.get(lang, lang)
+ n += 1
+
+ try:
+ t0 = time.time()
+
+ # Translate title
+ t_title = translate_title(es_title, lang_name) if es_title else ''
+ if not t_title or t_title.upper() == es_title.upper():
+ t_title = p['post_title'] # keep existing if translation failed
+
+ # Translate content chunk by chunk
+ t_content, ratio = translate_content_chunked(es_content, lang_name)
+ elapsed = time.time() - t0
+
+ # Validate overall content language
+ content_lang = detect_lang(t_content, min_len=80)
+ lang_ok = (content_lang == lang) or content_lang is None
+
+ # Add AI footer
+ if AI_FOOTER.strip() not in t_content:
+ t_content = t_content + AI_FOOTER
+
+ # Update DB
+ db2 = pymysql.connect(**DB)
+ c2 = db2.cursor()
+ c2.execute("UPDATE wp_posts SET post_title=%s, post_content=%s WHERE ID=%s",
+ (t_title, t_content, post_id))
+ db2.commit()
+ db2.close()
+
+ status = "✓" if (lang_ok and ratio == 1.0) else ("~" if lang_ok else "⚠")
+ if ratio < 1.0:
+ partial += 1
+ elif lang_ok:
+ done += 1
+ else:
+ errors += 1
+
+ print(f" [{lang}] {status} {post_id}: {t_title[:50]} ({elapsed:.0f}s, {ratio:.0%} ok)")
+
+ except Exception as e:
+ print(f" [{lang}] ✗ ERROR on {post_id}: {e}")
+ errors += 1
+
+ print(f"\n{'='*50}")
+ print(f"Done: {done} ✓ partial: {partial} ~ errors/wrong-lang: {errors} ⚠ skipped: {skipped}")
+ print(f"Total: {n}/{total}")
+
+
+if __name__ == "__main__":
+ main()
diff --git a/scripts/retranslate_en_all.py b/scripts/retranslate_en_all.py
new file mode 100644
index 0000000..7bb398d
--- /dev/null
+++ b/scripts/retranslate_en_all.py
@@ -0,0 +1,230 @@
+#!/usr/bin/env python3
+"""
+retranslate_en_all.py
+
+Retranslates ALL English posts (ID > 42760) from their Spanish originals.
+Uses chunk-based translation (~800 chars per chunk) to avoid model drift.
+Sequential, single process.
+"""
+
+import pymysql, json, re, html, urllib.request, time, sys
+from langdetect import detect, LangDetectException, DetectorFactory
+DetectorFactory.seed = 0
+
+JAN_URL = "http://172.19.128.1:1337/v1/chat/completions"
+JAN_MODEL = "gemma-3-12b-it-Q4_K_M"
+
+DB = dict(host='172.18.0.2', port=3306, user='wordpress_user',
+ password='wordpress_pass', database='wordpress_db', charset='utf8mb4',
+ cursorclass=pymysql.cursors.DictCursor)
+
+CHUNK_SIZE = 800
+MAX_RETRIES = 2
+AI_FOOTER = "\nTraducido con IA
"
+
+
+def strip_html(text):
+ if not text: return ''
+ text = re.sub(r'<[^>]+>', ' ', text)
+ text = html.unescape(text)
+ return re.sub(r'\s+', ' ', text).strip()
+
+
+def detect_lang(text, min_len=40):
+ t = strip_html(text)[:400].strip()
+ if len(t) < min_len: return None
+ try:
+ from langdetect import detect as _detect
+ return _detect(t)
+ except: return None
+
+
+def call_jan(messages, max_tokens=1200, temperature=0.2, timeout=120):
+ payload = json.dumps({
+ "model": JAN_MODEL, "messages": messages,
+ "temperature": temperature, "max_tokens": max_tokens,
+ }).encode("utf-8")
+ req = urllib.request.Request(
+ JAN_URL, data=payload,
+ headers={"Content-Type": "application/json", "Authorization": "Bearer dummy"},
+ method="POST"
+ )
+ with urllib.request.urlopen(req, timeout=timeout) as r:
+ return json.loads(r.read())["choices"][0]["message"]["content"].strip()
+
+
+def translate_chunk(chunk, attempt=0):
+ prompts = [
+ "You are a professional translator. Translate the following Spanish text to English. Preserve all HTML tags exactly. Return ONLY the translated text, no preamble, no explanation.",
+ "Translate from Spanish to English. Your entire response must be in English. Preserve HTML tags. Return ONLY the translation, nothing else.",
+ ]
+ system = prompts[min(attempt, len(prompts)-1)]
+ result = call_jan([
+ {"role": "system", "content": system},
+ {"role": "user", "content": chunk}
+ ])
+ # Short chunks: retry if output == input (model didn't translate)
+ plain_in = strip_html(chunk).strip().lower()
+ plain_out = strip_html(result).strip().lower()
+ if len(plain_in) < 40 and plain_in == plain_out and attempt == 0:
+ return translate_chunk(chunk, attempt=1)
+ return result
+
+
+def translate_title(es_title):
+ try:
+ result = call_jan([
+ {"role": "system", "content": "You are a translator. Respond ONLY with the translated text, nothing else."},
+ {"role": "user", "content": f"Translate from Spanish to English, ALL CAPS:\n\n{es_title}"}
+ ], max_tokens=150, temperature=0.1, timeout=30)
+ result = result.strip().strip('"').strip("'")
+ # Reject if identical to original
+ if result.upper() == es_title.upper():
+ return es_title
+ return result
+ except:
+ return es_title
+
+
+def split_chunks(content):
+ parts = re.split(r'(|||)', content)
+ chunks, current = [], ""
+ for i in range(0, len(parts), 2):
+ segment = parts[i] + (parts[i+1] if i+1 < len(parts) else "")
+ if len(current) + len(segment) <= CHUNK_SIZE:
+ current += segment
+ else:
+ if current: chunks.append(current)
+ if len(segment) > CHUNK_SIZE:
+ # Split long segment at sentence boundaries
+ sentences = re.split(r'(?<=[.!?])\s+', segment)
+ current = ""
+ for s in sentences:
+ if len(current) + len(s) <= CHUNK_SIZE:
+ current += s + " "
+ else:
+ if current: chunks.append(current.strip())
+ current = s + " "
+ else:
+ current = segment
+ if current: chunks.append(current)
+ return [c for c in chunks if strip_html(c).strip()]
+
+
+def main():
+ db = pymysql.connect(**DB)
+ c = db.cursor()
+
+ # Fetch all EN posts with their Spanish originals
+ c.execute("""
+ SELECT DISTINCT p.ID, p.post_title,
+ ttg.description as group_desc
+ FROM wp_posts p
+ JOIN wp_term_relationships trl ON p.ID=trl.object_id
+ JOIN wp_term_taxonomy ttl ON trl.term_taxonomy_id=ttl.term_taxonomy_id AND ttl.taxonomy='language'
+ JOIN wp_terms t_lang ON ttl.term_id=t_lang.term_id AND t_lang.slug='en'
+ JOIN wp_term_relationships trg ON p.ID=trg.object_id
+ JOIN wp_term_taxonomy ttg ON trg.term_taxonomy_id=ttg.term_taxonomy_id AND ttg.taxonomy='post_translations'
+ WHERE p.ID > 42760 AND p.post_type='post' AND p.post_status='publish'
+ ORDER BY p.ID
+ """)
+ posts = c.fetchall()
+ print(f"Found {len(posts)} EN posts to retranslate\n", flush=True)
+
+ done = errors = skipped = 0
+ total = len(posts)
+
+ for n, p in enumerate(posts, 1):
+ post_id = p['ID']
+ desc = p['group_desc'] or ''
+ m = re.search(r's:2:"es";i:(\d+);', desc)
+ if not m:
+ print(f"[{n}/{total}] {post_id} — SKIP (no ES original in group)", flush=True)
+ skipped += 1
+ continue
+
+ es_id = int(m.group(1))
+ c.execute("SELECT post_title, post_content FROM wp_posts WHERE ID=%s", (es_id,))
+ es = c.fetchone()
+ if not es or not es['post_content']:
+ print(f"[{n}/{total}] {post_id} — SKIP (ES:{es_id} empty)", flush=True)
+ skipped += 1
+ continue
+
+ es_title = es['post_title'] or ''
+ es_content = es['post_content']
+ plain_len = len(strip_html(es_content))
+ chunks = split_chunks(es_content)
+
+ print(f"\n[{n}/{total}] WP:{post_id} ← ES:{es_id} — {es_title[:50]}", flush=True)
+ print(f" {plain_len} chars, {len(chunks)} chunks", flush=True)
+
+ if plain_len < 50:
+ print(f" SKIP (too short)", flush=True)
+ skipped += 1
+ continue
+
+ try:
+ t0 = time.time()
+
+ # Translate title
+ t_title = translate_title(es_title)
+
+ # Translate content chunk by chunk
+ translated = []
+ chunk_ok = chunk_bad = 0
+ for i, chunk in enumerate(chunks):
+ try:
+ result = translate_chunk(chunk, attempt=0)
+ lang = detect_lang(result, min_len=40)
+
+ if lang and lang != 'en' and len(strip_html(result)) >= 40:
+ result2 = translate_chunk(chunk, attempt=1)
+ lang2 = detect_lang(result2, min_len=40)
+ if lang2 == 'en' or lang2 is None:
+ result = result2
+ chunk_ok += 1
+ else:
+ chunk_bad += 1
+ else:
+ chunk_ok += 1
+ translated.append(result)
+ except Exception as e:
+ print(f" chunk {i+1} ERROR: {e}", flush=True)
+ translated.append(chunk)
+ chunk_bad += 1
+
+ t_content = "\n".join(translated)
+ if AI_FOOTER.strip() not in t_content:
+ t_content += AI_FOOTER
+
+ # Validate overall
+ content_lang = detect_lang(t_content, min_len=80)
+ lang_ok = content_lang in ('en', None)
+ elapsed = time.time() - t0
+
+ # Save
+ db2 = pymysql.connect(**DB)
+ c2 = db2.cursor()
+ c2.execute("UPDATE wp_posts SET post_title=%s, post_content=%s WHERE ID=%s",
+ (t_title, t_content, post_id))
+ db2.commit()
+ db2.close()
+
+ status = "✓" if lang_ok else "⚠"
+ bad_note = f" ({chunk_bad} chunks bad)" if chunk_bad else ""
+ print(f" {status} {t_title[:60]} ({elapsed:.0f}s){bad_note}", flush=True)
+ done += 1
+
+ except Exception as e:
+ print(f" ✗ ERROR: {e}", flush=True)
+ errors += 1
+
+ db.close()
+ print(f"\n{'='*50}")
+ print(f"Done: {done} ✓ errors: {errors} ✗ skipped: {skipped}")
+ print(f"Total: {total}")
+
+
+if __name__ == "__main__":
+ main()
diff --git a/scripts/retranslate_failures.py b/scripts/retranslate_failures.py
new file mode 100644
index 0000000..af2a41e
--- /dev/null
+++ b/scripts/retranslate_failures.py
@@ -0,0 +1,233 @@
+#!/usr/bin/env python3
+"""
+retranslate_failures.py
+
+Re-translates posts where content is in the wrong language.
+Reads the audit CSV (/tmp/audit_clean.csv), fetches Spanish originals,
+retranslates content (and title if needed), and updates the DB.
+
+Uses a clean prompt WITHOUT few-shot examples to avoid contamination.
+"""
+
+import pymysql
+import json
+import re
+import html
+import urllib.request
+import urllib.error
+import time
+import sys
+import csv
+from langdetect import detect, LangDetectException, DetectorFactory
+DetectorFactory.seed = 0
+
+JAN_URL = "http://172.19.128.1:1337/v1/chat/completions"
+JAN_MODEL = "gemma-3-12b-it-Q4_K_M"
+
+DB = dict(host='172.18.0.2', port=3306, user='wordpress_user',
+ password='wordpress_pass', database='wordpress_db', charset='utf8mb4',
+ cursorclass=pymysql.cursors.DictCursor)
+
+LANG_NAMES = {"en": "English", "fr": "French", "it": "Italian", "pt": "Portuguese"}
+LANG_NORM = {'es':'es','pt':'pt','fr':'fr','en':'en','it':'it','ca':'es','gl':'es'}
+
+AI_FOOTER = "\nTraducido con IA
"
+
+
+def strip_html(text):
+ if not text: return ''
+ text = re.sub(r'<[^>]+>', ' ', text)
+ text = html.unescape(text)
+ return re.sub(r'\s+', ' ', text).strip()
+
+
+def detect_lang(text, min_len=80):
+ t = strip_html(text)[:600].strip()
+ if len(t) < min_len: return None
+ try: return LANG_NORM.get(detect(t), detect(t))
+ except: return None
+
+
+def call_jan(messages, max_tokens=4096, temperature=0.3, timeout=300):
+ payload = json.dumps({
+ "model": JAN_MODEL,
+ "messages": messages,
+ "temperature": temperature,
+ "max_tokens": max_tokens,
+ }).encode("utf-8")
+ req = urllib.request.Request(
+ JAN_URL, data=payload,
+ headers={"Content-Type": "application/json", "Authorization": "Bearer dummy"},
+ method="POST"
+ )
+ with urllib.request.urlopen(req, timeout=timeout) as r:
+ result = json.loads(r.read())
+ return result["choices"][0]["message"]["content"].strip()
+
+
+def translate_content(title, content, lang_code, lang_name):
+ """Translate title + content using a clean prompt (no few-shot contamination)."""
+ system = (
+ f"You are a professional translator specializing in theological and religious texts. "
+ f"Translate from Spanish to {lang_name}. "
+ f"Rules: preserve all HTML tags exactly; translate the title literally in ALL CAPS; "
+ f"maintain formal theological register; translate standard religious proper nouns (e.g. 'Jesús' → 'Jesus' in English); "
+ f"keep person/place names as-is; return ONLY the translation starting with 'Title:'"
+ )
+ user = f"Title: {title}\n\n{content}"
+ response = call_jan([
+ {"role": "system", "content": system},
+ {"role": "user", "content": user}
+ ])
+
+ lines = response.split("\n", 2)
+ if lines[0].startswith("Title:"):
+ t_title = lines[0].replace("Title:", "").strip()
+ t_content = "\n".join(lines[1:]).strip() if len(lines) > 1 else ""
+ else:
+ t_title = lines[0].strip()
+ t_content = "\n".join(lines[1:]).strip() if len(lines) > 1 else response
+
+ return t_title, t_content
+
+
+def translate_title_only(title, lang_name):
+ response = call_jan([
+ {"role": "system", "content": "You are a translator. Respond ONLY with the translated text, nothing else."},
+ {"role": "user", "content": f"Translate from Spanish to {lang_name}, ALL CAPS:\n\n{title}"}
+ ], max_tokens=120, temperature=0.1, timeout=30)
+ return response.strip().strip('"').strip("'")
+
+
+def main():
+ # Load audit results
+ audit_path = '/tmp/audit_clean.csv'
+ failed_ids = set()
+ try:
+ with open(audit_path) as f:
+ reader = csv.DictReader(f)
+ for row in reader:
+ failed_ids.add(int(row['id']))
+ print(f"Loaded {len(failed_ids)} post IDs with issues from audit")
+ except FileNotFoundError:
+ print(f"ERROR: {audit_path} not found. Run audit_translations.py first.")
+ sys.exit(1)
+
+ db = pymysql.connect(**DB)
+ c = db.cursor()
+
+ # Fetch failed posts - get lang and translation group description
+ id_list = ','.join(str(i) for i in sorted(failed_ids))
+ c.execute(f"""
+ SELECT DISTINCT p.ID, p.post_title, p.post_content,
+ t_lang.slug as lang,
+ ttg.description as group_desc
+ FROM wp_posts p
+ JOIN wp_term_relationships trl ON p.ID=trl.object_id
+ JOIN wp_term_taxonomy ttl ON trl.term_taxonomy_id=ttl.term_taxonomy_id AND ttl.taxonomy='language'
+ JOIN wp_terms t_lang ON ttl.term_id=t_lang.term_id
+ JOIN wp_term_relationships trg ON p.ID=trg.object_id
+ JOIN wp_term_taxonomy ttg ON trg.term_taxonomy_id=ttg.term_taxonomy_id AND ttg.taxonomy='post_translations'
+ WHERE p.ID IN ({id_list}) AND p.post_type='post' AND p.post_status='publish'
+ """)
+ raw_posts = c.fetchall()
+
+ # Extract Spanish ID from group description and fetch Spanish content
+ import re as _re
+ posts = []
+ es_cache = {}
+ for p in raw_posts:
+ desc = p['group_desc'] or ''
+ m = _re.search(r's:2:"es";i:(\d+);', desc)
+ if not m:
+ continue
+ es_id = int(m.group(1))
+ if es_id not in es_cache:
+ c.execute("SELECT ID, post_title, post_content FROM wp_posts WHERE ID=%s", (es_id,))
+ row = c.fetchone()
+ es_cache[es_id] = row
+ es = es_cache[es_id]
+ if es:
+ posts.append({**p, 'es_id': es_id, 'es_title': es['post_title'], 'es_content': es['post_content']})
+ db.close()
+ print(f"Fetched {len(posts)} posts to retranslate\n")
+
+ # Group by Spanish original to avoid redundant API calls
+ by_es = {}
+ for p in posts:
+ by_es.setdefault(p['es_id'], []).append(p)
+
+ done = errors = skipped = 0
+ total = len(posts)
+ n = 0
+
+ for es_id, translations in sorted(by_es.items()):
+ es_title = translations[0]['es_title']
+ es_content = translations[0]['es_content'] or ''
+ content_len = len(strip_html(es_content))
+
+ if content_len < 50:
+ print(f" ES:{es_id} — SKIPPING (content too short: {content_len} chars)")
+ skipped += len(translations)
+ n += len(translations)
+ continue
+
+ print(f"\nES:{es_id} — {(es_title or '')[:50]} ({content_len} chars)")
+
+ for p in translations:
+ post_id = p['ID']
+ lang = p['lang']
+ lang_name = LANG_NAMES.get(lang, lang)
+ n += 1
+
+ try:
+ t0 = time.time()
+ t_title, t_content = translate_content(es_title or '', es_content, lang, lang_name)
+ elapsed = time.time() - t0
+
+ # Validate: content should now be in target language
+ content_lang = detect_lang(t_content, min_len=80)
+ ok = (content_lang == lang) or content_lang is None
+
+ # If still wrong language, retry with simpler prompt
+ if not ok and content_lang:
+ print(f" [{lang}] ⚠ Content still {content_lang}, retrying...")
+ retry_response = call_jan([
+ {"role": "system", "content": f"You are a professional translator. Translate the following Spanish text to {lang_name}. Preserve all HTML tags. Return ONLY the translated text, no preamble, no explanation."},
+ {"role": "user", "content": es_content}
+ ])
+ t_content = retry_response
+ content_lang2 = detect_lang(t_content, min_len=80)
+ if content_lang2 == lang or content_lang2 is None:
+ print(f" [{lang}] ✓ Retry succeeded ({content_lang2})")
+ ok = True
+ else:
+ print(f" [{lang}] ✗ Retry still {content_lang2}, saving anyway")
+
+ # Add AI footer if not present
+ if AI_FOOTER.strip() not in t_content:
+ t_content = t_content + AI_FOOTER
+
+ # Update DB
+ db2 = pymysql.connect(**DB)
+ c2 = db2.cursor()
+ c2.execute("UPDATE wp_posts SET post_title=%s, post_content=%s WHERE ID=%s",
+ (t_title, t_content, post_id))
+ db2.commit()
+ db2.close()
+
+ status = "✓" if ok else "⚠"
+ print(f" [{lang}] {status} {post_id}: {t_title[:50]} ({elapsed:.0f}s)")
+ done += 1
+
+ except Exception as e:
+ print(f" [{lang}] ✗ ERROR on {post_id}: {e}")
+ errors += 1
+
+ print(f"\n{'='*50}")
+ print(f"Done: {done} retranslated, {errors} errors, {skipped} skipped")
+ print(f"Total processed: {n}/{total}")
+
+
+if __name__ == "__main__":
+ main()
diff --git a/scripts/retranslate_lang.py b/scripts/retranslate_lang.py
new file mode 100644
index 0000000..610249c
--- /dev/null
+++ b/scripts/retranslate_lang.py
@@ -0,0 +1,275 @@
+#!/usr/bin/env python3
+"""
+retranslate_lang.py
+
+Retranslates ALL posts for a given language (ID > 42760) from their Spanish originals.
+Uses chunk-based translation (~800 chars per chunk) to avoid model drift.
+Sequential, single process.
+
+Usage: python3 retranslate_lang.py fr
+ python3 retranslate_lang.py it
+ python3 retranslate_lang.py pt
+"""
+
+import pymysql, json, re, html, urllib.request, time, sys
+from langdetect import detect, LangDetectException, DetectorFactory
+DetectorFactory.seed = 0
+
+JAN_URL = "http://172.19.128.1:1337/v1/chat/completions"
+JAN_MODEL = "gemma-3-12b-it-Q4_K_M"
+
+DB = dict(host='172.18.0.2', port=3306, user='wordpress_user',
+ password='wordpress_pass', database='wordpress_db', charset='utf8mb4',
+ cursorclass=pymysql.cursors.DictCursor)
+
+LANG_CONFIG = {
+ "en": {"name": "English", "footer": "English version translated with AI
"},
+ "fr": {"name": "French", "footer": "Version française traduite par IA
"},
+ "it": {"name": "Italian", "footer": "Versione italiana tradotta con IA
"},
+ "pt": {"name": "Portuguese", "footer": "Versão portuguesa traduzida com IA
"},
+}
+
+CHUNK_SIZE = 800
+MAX_RETRIES = 2
+
+
+def strip_html(text):
+ if not text: return ''
+ text = re.sub(r'<[^>]+>', ' ', text)
+ text = html.unescape(text)
+ return re.sub(r'\s+', ' ', text).strip()
+
+
+def detect_lang(text, min_len=40):
+ t = strip_html(text)[:400].strip()
+ if len(t) < min_len: return None
+ try: return detect(t)
+ except: return None
+
+
+def call_jan(messages, max_tokens=1200, temperature=0.2, timeout=150):
+ payload = json.dumps({
+ "model": JAN_MODEL, "messages": messages,
+ "temperature": temperature, "max_tokens": max_tokens,
+ }).encode("utf-8")
+ req = urllib.request.Request(
+ JAN_URL, data=payload,
+ headers={"Content-Type": "application/json", "Authorization": "Bearer dummy"},
+ method="POST"
+ )
+ with urllib.request.urlopen(req, timeout=timeout) as r:
+ return json.loads(r.read())["choices"][0]["message"]["content"].strip()
+
+
+def fix_html_structure(content):
+ """Fix common model errors: markdown bold → HTML, orphaned text → wrapped,
+ unclosed
before a new
."""
+ # **text** →
text
+ content = re.sub(r'\*\*(.+?)\*\*',
+ lambda m: '' + m.group(1).strip() + '
',
+ content)
+ # Lines of bare text not inside any block tag → wrap in
+ lines = content.split('\n')
+ fixed = []
+ for line in lines:
+ s = line.strip()
+ if s and not s.startswith('<') and not s.startswith('
+
+
+
+
+
+
+
+
+
+
+
+
+
Lo siento, no se ha encontrado nada. Por favor, prueba a buscar con otras palabras clave.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
Traducido con IA
"
+
+
+def strip_html(text):
+ if not text: return ''
+ text = re.sub(r'<[^>]+>', ' ', text)
+ text = html.unescape(text)
+ return re.sub(r'\s+', ' ', text).strip()
+
+
+def detect_lang(text, min_len=40):
+ t = strip_html(text)[:400].strip()
+ if len(t) < min_len: return None
+ try: return detect(t)
+ except: return None
+
+
+def call_jan(messages, max_tokens=1200, temperature=0.2, timeout=120):
+ payload = json.dumps({
+ "model": JAN_MODEL, "messages": messages,
+ "temperature": temperature, "max_tokens": max_tokens,
+ }).encode("utf-8")
+ req = urllib.request.Request(
+ JAN_URL, data=payload,
+ headers={"Content-Type": "application/json", "Authorization": "Bearer dummy"},
+ method="POST"
+ )
+ with urllib.request.urlopen(req, timeout=timeout) as r:
+ return json.loads(r.read())["choices"][0]["message"]["content"].strip()
+
+
+def translate_chunk(chunk, attempt=0):
+ prompts = [
+ "You are a professional translator. Translate the following Spanish text to English. Preserve all HTML tags exactly. Return ONLY the translated text, no preamble.",
+ "Translate from Spanish to English. Your response must be entirely in English. Preserve HTML tags. Return ONLY the translation.",
+ ]
+ system = prompts[min(attempt, len(prompts)-1)]
+ result = call_jan([
+ {"role": "system", "content": system},
+ {"role": "user", "content": chunk}
+ ])
+ # For very short chunks, retry if result == original (model didn't translate)
+ plain_in = strip_html(chunk).strip().lower()
+ plain_out = strip_html(result).strip().lower()
+ if len(plain_in) < 40 and plain_in == plain_out and attempt == 0:
+ return translate_chunk(chunk, attempt=1)
+ return result
+
+
+def split_chunks(content):
+ parts = re.split(r'(|||)', content)
+ chunks, current = [], ""
+ for i in range(0, len(parts), 2):
+ segment = parts[i] + (parts[i+1] if i+1 < len(parts) else "")
+ if len(current) + len(segment) <= CHUNK_SIZE:
+ current += segment
+ else:
+ if current: chunks.append(current)
+ current = segment
+ if current: chunks.append(current)
+ return [c for c in chunks if strip_html(c).strip()]
+
+
+def main():
+ db = pymysql.connect(**DB)
+ c = db.cursor()
+
+ for wp_en_id, es_id in TEST_POSTS:
+ c.execute("SELECT post_title, post_content FROM wp_posts WHERE ID=%s", (es_id,))
+ es = c.fetchone()
+ if not es:
+ print(f"\n[SKIP] ES:{es_id} not found"); continue
+
+ es_title = es['post_title'] or ''
+ es_content = es['post_content'] or ''
+ chunks = split_chunks(es_content)
+ plain_len = len(strip_html(es_content))
+
+ print(f"\n{'='*60}")
+ print(f"WP:{wp_en_id} ← ES:{es_id}")
+ print(f"Title: {es_title[:60]}")
+ print(f"Content: {plain_len} chars, {len(chunks)} chunks")
+ print(f"{'='*60}")
+
+ # Translate title
+ try:
+ t0 = time.time()
+ t_title = call_jan([
+ {"role": "system", "content": "You are a translator. Respond ONLY with the translated text."},
+ {"role": "user", "content": f"Translate from Spanish to English, ALL CAPS:\n\n{es_title}"}
+ ], max_tokens=120, temperature=0.1, timeout=30)
+ t_title = t_title.strip().strip('"').strip("'")
+ print(f"Title [{detect_lang(t_title) or '?'}]: {t_title[:70]} ({time.time()-t0:.0f}s)")
+ except Exception as e:
+ t_title = es_title
+ print(f"Title ERROR: {e}")
+
+ # Translate chunks
+ translated = []
+ ok = bad = 0
+ for i, chunk in enumerate(chunks):
+ try:
+ t0 = time.time()
+ result = translate_chunk(chunk, attempt=0)
+ lang = detect_lang(result) or '?'
+
+ if lang not in ('en', None, '?') and len(strip_html(result)) > 40:
+ # Retry
+ result2 = translate_chunk(chunk, attempt=1)
+ lang2 = detect_lang(result2) or '?'
+ if lang2 == 'en' or lang2 in ('?', None):
+ result, lang = result2, lang2
+ print(f" chunk {i+1}/{len(chunks)} [retry→{lang}] {time.time()-t0:.0f}s ✓")
+ else:
+ print(f" chunk {i+1}/{len(chunks)} [STILL {lang2}] {time.time()-t0:.0f}s ⚠ — keeping anyway")
+ bad += 1
+ else:
+ print(f" chunk {i+1}/{len(chunks)} [{lang}] {time.time()-t0:.0f}s ✓")
+ ok += 1
+
+ translated.append(result)
+ except Exception as e:
+ print(f" chunk {i+1}/{len(chunks)} ERROR: {e}")
+ translated.append(chunk) # keep original
+ bad += 1
+
+ t_content = "\n".join(translated)
+ if AI_FOOTER.strip() not in t_content:
+ t_content += AI_FOOTER
+
+ # Save to DB
+ c.execute("UPDATE wp_posts SET post_title=%s, post_content=%s WHERE ID=%s",
+ (t_title, t_content, wp_en_id))
+ db.commit()
+
+ ratio = ok / len(chunks) if chunks else 1.0
+ print(f" → Saved. {ok}/{len(chunks)} chunks ok ({ratio:.0%})")
+ print(f" → Check: http://localhost:8081/?p={wp_en_id}")
+
+ db.close()
+ print(f"\n{'='*60}")
+ print("Done. Review the 5 posts in WP admin before running full batch.")
+ print("URLs to check:")
+ for wp_en_id, _ in TEST_POSTS:
+ print(f" http://localhost:8081/?p={wp_en_id}")
+
+
+if __name__ == "__main__":
+ main()
diff --git a/scripts/trad_cats.php b/scripts/trad_cats.php
new file mode 100644
index 0000000..cb353a7
--- /dev/null
+++ b/scripts/trad_cats.php
@@ -0,0 +1,38 @@
+ [en,fr,it,pt])
+$D = [
+ 410 => ['Nuevo Testamento', 'New Testament','Nouveau Testament','Nuovo Testamento','Novo Testamento'],
+ 411 => ['Antiguo Testamento','Old Testament','Ancien Testament','Antico Testamento','Antigo Testamento'],
+ 49 => ['Adviento y Navidad','Advent and Christmas','Avent et Noël','Avvento e Natale','Advento e Natal'],
+ 12 => ['In memoriam','In Memoriam','In Memoriam','In Memoriam','In Memoriam'],
+ 1651 => ['Noticias','News','Actualités','Notizie','Notícias'],
+ 61 => ['Comunidades cristianas','Christian Communities','Communautés chrétiennes','Comunità cristiane','Comunidades cristãs'],
+ 23 => ['Cartas que nos llegan','Letters We Receive','Lettres reçues','Lettere che riceviamo','Cartas que recebemos'],
+ 39 => ['Temas','Topics','Thèmes','Temi','Temas'],
+ 27 => ['Índice cronológico','Chronological Index','Index chronologique','Indice cronologico','Índice cronológico'],
+ 63 => ['EFFA','EFFA','EFFA','EFFA','EFFA'],
+];
+$LangSlug = ['en'=>'en','fr'=>'fr','it'=>'it','pt'=>'pt'];
+$created=0;
+foreach ($D as $es_id => $names) {
+ $es_term = get_term($es_id, 'category');
+ if (!$es_term || is_wp_error($es_term)) { echo "skip $es_id (no existe)\n"; continue; }
+ $existing = pll_get_term_translations($es_id);
+ $group = $existing;
+ $i = 1;
+ foreach (['en','fr','it','pt'] as $L) {
+ $i++;
+ if (!empty($existing[$L])) { $group[$L]=$existing[$L]; continue; }
+ $name = $names[$i-1];
+ $slug = sanitize_title($name).'-'.$L;
+ $res = wp_insert_term($name, 'category', ['slug'=>$slug]);
+ if (is_wp_error($res)) { echo " $es_id $L ERROR: ".$res->get_error_message()."\n"; continue; }
+ $tid = $res['term_id'];
+ pll_set_term_language($tid, $L);
+ $group[$L] = $tid;
+ $created++;
+ }
+ pll_save_term_translations($group);
+ echo "#$es_id ".$names[0]." → ".implode(",", array_map(function($k,$v){return $k.":".$v;}, array_keys($group),$group))."\n";
+}
+echo "términos traducidos creados: $created\n";
diff --git a/scripts/translate_cartas.py b/scripts/translate_cartas.py
new file mode 100644
index 0000000..5be0da8
--- /dev/null
+++ b/scripts/translate_cartas.py
@@ -0,0 +1,401 @@
+#!/usr/bin/env python3
+"""
+translate_cartas.py
+
+Traduce artículos españoles de las últimas 2 cartas semanales usando Jan (Gemma 12B).
+Crea los posts traducidos en WordPress local (Docker) y los vincula con Polylang.
+
+Uso:
+ 1. Arranca Jan con Gemma 12B
+ 2. python3 translate_cartas.py --check-api # verifica conexión a Jan
+ 3. python3 translate_cartas.py --dry-run # muestra qué se traduciría
+ 4. python3 translate_cartas.py # traduce todo
+ 5. python3 translate_cartas.py --lang en # solo un idioma
+ 6. python3 translate_cartas.py --id 42579 # solo un artículo
+"""
+
+import subprocess
+import json
+import re
+import sys
+import time
+import argparse
+import pymysql
+
+# ── Configuración ─────────────────────────────────────────────────────────────
+JAN_URL = "http://172.19.128.1:1337/v1/chat/completions"
+JAN_MODEL = "gemma-3-12b-it-Q4_K_M"
+
+DB_HOST = "172.18.0.2"
+DB_PORT = 3306
+DB_NAME = "wordpress_db"
+DB_USER = "wordpress_user"
+DB_PASS = "wordpress_pass"
+
+WP_CONTAINER = "wordpress-web"
+
+TARGET_LANGS = {
+ "en": "English",
+ "fr": "French",
+ "it": "Italian",
+ "pt": "Portuguese",
+}
+
+# IDs de artículos en español de todas las cartas de 2026
+# (excluye 26899 = 42k chars, demasiado largo para Jan)
+SPANISH_IDS = [
+ # Carta 2026-03-05 (Agua Viva) — las 2 últimas ya traducidas, se saltarán automáticamente
+ 42732, 42731, 42730, 42729, 42728, 42727, 42726, 42590,
+ 42579, 42578, 42577, 42576, 42575, 42574, 42573, 42572, 42571,
+ 42570, 42569, 42568, 42567, 42566, 42565, 42564, 42563, 42562,
+ 42561, 42560, 42559, 42558, 42557, 42556,
+ # Carta 2026-02-26 (¿Creemos en el evangelio?)
+ 42594, 42555, 42554, 42553, 42552, 42551, 42550, 42549, 42548, 42547,
+ 42546, 42545, 42544, 42543, 42542, 42541, 42540, 42539, 42538,
+ 42537, 42536, 42535, 42534, 42533, 42532, 42531, 42530, 42529,
+ 42528, 42527, 42526, 42525, 42524, 42523,
+ # Carta 2026-02-19 (Seres limitados)
+ 42589, 42517, 42516, 42515, 42514, 42513, 42512, 42511,
+ 42510, 42509, 42508, 42507, 42506, 42518, 42505, 42504, 42503,
+ 42502, 42501,
+ # Carta 2026-02-12 (Más allá de la ley)
+ 42588, 42500, 42499, 42498, 42497, 42496, 42495, 42490,
+ 42489, 42488, 42487, 42486, 42485, 42484, 42587, 42478,
+ # Carta 2026-02-05 (Ser sal, ser luz)
+ 42477, 42476, 42475, 42474, 42473, 42472, 42471, 42470,
+ 42469, 42468, 42467, 42466, 42465, 42464, 42586, 42479,
+ # Carta 2026-01-29 (Bienaventurados)
+ 42459, 42458, 42457, 42456, 42455, 42454, 42453, 42452,
+ 42451, 42585, 42450, 42463, 42462, 42461, 42460, 42445, 42444,
+ # Carta 2026-01-22 (Nuevos caminos)
+ 42584, 42443, 42442, 42441, 42440, 42439, 42438, 42437,
+ 42436, 42431, 42430, 42429, 42428, 42427, 42426, 42425, 42424,
+ # Carta 2026-01-15 (La ley del Oeste)
+ 26899, # 42k chars — se saltará por tamaño
+ 26898, 26897, 26896, 26895, 26894, 26893, 26892,
+ 26714, 26713, 26712, 26711, 26710, 26717, 26887, 26716, 26886, 26715,
+ # Carta 2026-01-08 (Hakuna / Avivando ilusiones)
+ 26885, 26884, 26883, 26882, 26881, 26880, 26875, 26708,
+ 26707, 26706, 26705, 26704, 26703, 26702, 26874, 26873,
+ 26872, 26871, 26870, 26869, 26868, 26867, 26866, 26865,
+ # Carta 2026-01-01
+ 26864, 26863, 26862, 26861, 26860, 26859, 26858, 26857,
+ 26856, 26855, 26709,
+]
+
+# Tamaño máximo de contenido para traducción automática (chars)
+MAX_CONTENT_LEN = 35000
+
+AI_FOOTER = "\nTraducido con IA
"
+
+# ── Detectar modelo Jan ───────────────────────────────────────────────────────
+def get_jan_model():
+ import urllib.request
+ try:
+ req_m = urllib.request.Request(JAN_URL.replace("/chat/completions", "/models"), headers={"Authorization": "Bearer dummy"})
+ with urllib.request.urlopen(req_m, timeout=5) as r:
+ data = json.loads(r.read())
+ models = data.get("data", [])
+ if models:
+ return models[0]["id"]
+ except Exception as e:
+ print(f"ERROR: No se puede conectar a Jan en {JAN_URL}")
+ print(f" {e}")
+ print(" Asegúrate de que Jan está corriendo con Gemma 12B cargado.")
+ sys.exit(1)
+ return "gemma"
+
+# ── Traducción via Jan ────────────────────────────────────────────────────────
+def translate(title, content, lang_code, lang_name):
+ import urllib.request, urllib.error
+
+ # Few-shot examples from existing human translations (Pagola) to guide style
+ few_shot = {
+ "en": [
+ ("NO SABEMOS SABOREAR LA FE", "WE DON'T KNOW HOW TO SAVOR FAITH"),
+ ("ESCUCHAR A JESÚS EN LA SOCIEDAD ACTUAL", "LISTENING TO JESUS IN TODAY'S SOCIETY"),
+ ("FIELES A JESÚS EN MEDIO DE LAS TENTACIONES", "FAITHFUL TO JESUS IN TEMPTATIONS"),
+ ],
+ "fr": [
+ ("NO SABEMOS SABOREAR LA FE", "NOUS NE SAVONS PAS APPRÉCIER LA FOI"),
+ ("ESCUCHAR A JESÚS EN LA SOCIEDAD ACTUAL", "ÉCOUTER JÉSUS DANS LA SOCIÉTÉ ACTUELLE"),
+ ("FIELES A JESÚS EN MEDIO DE LAS TENTACIONES", "FIDÈLES À JÉSUS AU MILIEU DES TENTATIONS"),
+ ],
+ "it": [
+ ("NO SABEMOS SABOREAR LA FE", "NON SAPPIAMO ASSAPORARE LA FEDE"),
+ ("ESCUCHAR A JESÚS EN LA SOCIEDAD ACTUAL", "ASCOLTARE GESÙ NELLA SOCIETÀ ATTUALE"),
+ ("FIELES A JESÚS EN MEDIO DE LAS TENTACIONES", "FEDELI A GESÙ NELLE TENTAZIONI"),
+ ],
+ "pt": [
+ ("NO SABEMOS SABOREAR LA FE", "NÃO SABEMOS SABOREAR A FÉ"),
+ ("ESCUCHAR A JESÚS EN LA SOCIEDAD ACTUAL", "OUVIR JESUS NA SOCIEDADE ATUAL"),
+ ("FIELES A JESÚS EN MEDIO DE LAS TENTACIONES", "FIÉIS A JESUS NO MEIO DAS TENTAÇÕES"),
+ ],
+ }
+ example_lines = "\n".join(
+ f" ES: {e}\n {lang_code.upper()}: {t}"
+ for e, t in few_shot.get(lang_code, [])
+ )
+ example_block = f"\n\nTitle translation examples (be exactly this literal):\n{example_lines}" if example_lines else ""
+
+ system_prompt = f"""You are a professional translator specializing in theological and religious texts.
+Translate from Spanish to {lang_name}.
+Rules:
+- Preserve all HTML tags exactly as they appear
+- Translate the title LITERALLY — never paraphrase or summarize it
+- Keep the full title including everything after colons and quoted subtitles
+- Titles must be in ALL CAPS
+- Maintain formal theological register
+- Standard religious proper nouns: translate them (e.g. "Jesús" → "Jesus" in English)
+- Other proper nouns (person names, place names): keep as-is
+- Return ONLY the translation, starting with 'Title:'{example_block}"""
+
+ payload = json.dumps({
+ "model": JAN_MODEL,
+ "messages": [
+ {"role": "system", "content": system_prompt},
+ {"role": "user", "content": f"Title: {title}\n\n{content}"}
+ ],
+ "temperature": 0.3,
+ "max_tokens": 4096,
+ }).encode("utf-8")
+
+ req = urllib.request.Request(
+ JAN_URL,
+ data=payload,
+ headers={"Content-Type": "application/json", "Authorization": "Bearer dummy"},
+ method="POST"
+ )
+
+ try:
+ with urllib.request.urlopen(req, timeout=300) as r:
+ result = json.loads(r.read())
+ full = result["choices"][0]["message"]["content"].strip()
+ # Separar título traducido del contenido
+ lines = full.split("\n", 2)
+ if lines[0].startswith("Title:"):
+ translated_title = lines[0].replace("Title:", "").strip()
+ translated_content = "\n".join(lines[1:]).strip() if len(lines) > 1 else ""
+ else:
+ translated_title = lines[0].strip()
+ translated_content = "\n".join(lines[1:]).strip() if len(lines) > 1 else full
+
+ # Si el título volvió igual al original (sin traducir), reintentamos solo el título
+ if translated_title.strip().upper() == title.strip().upper():
+ title_payload = json.dumps({
+ "model": JAN_MODEL,
+ "messages": [
+ {"role": "user", "content": f"Translate this title from Spanish to {lang_name}. Return ONLY the translated title in ALL CAPS, nothing else: {title}"}
+ ],
+ "temperature": 0.2,
+ "max_tokens": 50,
+ }).encode("utf-8")
+ title_req = urllib.request.Request(JAN_URL, data=title_payload,
+ headers={"Content-Type": "application/json", "Authorization": "Bearer dummy"}, method="POST")
+ with urllib.request.urlopen(title_req, timeout=30) as tr:
+ title_result = json.loads(tr.read())
+ translated_title = title_result["choices"][0]["message"]["content"].strip().strip('"')
+
+ # Si el contenido traducido está vacío o es muy corto, reintentamos con prompt más directo
+ if len(translated_content.strip()) < 50 and len(content.strip()) > 50:
+ retry_payload = json.dumps({
+ "model": JAN_MODEL,
+ "messages": [
+ {"role": "system", "content": f"You are a professional translator. Translate the following text from Spanish to {lang_name}. Preserve all HTML tags. Return ONLY the translated text, no preamble."},
+ {"role": "user", "content": content}
+ ],
+ "temperature": 0.3,
+ "max_tokens": 4096,
+ }).encode("utf-8")
+ retry_req = urllib.request.Request(JAN_URL, data=retry_payload,
+ headers={"Content-Type": "application/json", "Authorization": "Bearer dummy"}, method="POST")
+ with urllib.request.urlopen(retry_req, timeout=300) as rr:
+ retry_result = json.loads(rr.read())
+ translated_content = retry_result["choices"][0]["message"]["content"].strip()
+
+ return translated_title, translated_content
+ except urllib.error.URLError as e:
+ raise RuntimeError(f"Error llamando a Jan: {e}")
+
+# ── Base de datos WordPress ───────────────────────────────────────────────────
+def get_db():
+ return pymysql.connect(
+ host=DB_HOST, port=DB_PORT,
+ user=DB_USER, password=DB_PASS,
+ database=DB_NAME, charset="utf8mb4",
+ cursorclass=pymysql.cursors.DictCursor
+ )
+
+def get_article(db, wp_id):
+ with db.cursor() as c:
+ c.execute("""
+ SELECT p.ID, p.post_title, p.post_content, p.post_author,
+ p.post_date, p.post_name,
+ GROUP_CONCAT(t.term_id) as term_ids
+ FROM wp_posts p
+ LEFT JOIN wp_term_relationships tr ON p.ID=tr.object_id
+ LEFT JOIN wp_term_taxonomy tt ON tr.term_taxonomy_id=tt.term_taxonomy_id
+ AND tt.taxonomy='category'
+ LEFT JOIN wp_terms t ON tt.term_id=t.term_id
+ WHERE p.ID=%s
+ GROUP BY p.ID
+ """, (wp_id,))
+ return c.fetchone()
+
+def get_existing_translation(db, original_id, lang_code):
+ """Devuelve el WP ID de la traducción si ya existe."""
+ with db.cursor() as c:
+ # Polylang guarda las traducciones en wp_term_relationships con taxonomy 'post_translations'
+ c.execute("""
+ SELECT tr2.object_id as translated_id
+ FROM wp_term_relationships tr1
+ JOIN wp_term_relationships tr2 ON tr1.term_taxonomy_id=tr2.term_taxonomy_id
+ JOIN wp_term_taxonomy tt1 ON tr1.term_taxonomy_id=tt1.term_taxonomy_id
+ WHERE tt1.taxonomy='post_translations'
+ AND tr1.object_id=%s AND tr2.object_id!=%s
+ """, (original_id, original_id))
+ candidates = [r['translated_id'] for r in c.fetchall()]
+ for cid in candidates:
+ c.execute("""
+ SELECT t.slug FROM wp_terms t
+ JOIN wp_term_taxonomy tt ON t.term_id=tt.term_id
+ JOIN wp_term_relationships tr ON tt.term_taxonomy_id=tr.term_taxonomy_id
+ WHERE tt.taxonomy='language' AND tr.object_id=%s
+ """, (cid,))
+ row = c.fetchone()
+ if row and row['slug'] == lang_code:
+ return cid
+ return None
+
+# ── Crear post vía WP-CLI en Docker ──────────────────────────────────────────
+def create_wp_post(article, translated_title, translated_content, lang_code, original_id, dry_run=False):
+ content_with_footer = translated_content + AI_FOOTER
+
+ php = f"""
+global $wpdb;
+$post_id = wp_insert_post([
+ 'post_title' => {json.dumps(translated_title, ensure_ascii=False)},
+ 'post_content' => {json.dumps(content_with_footer, ensure_ascii=False)},
+ 'post_author' => {article['post_author']},
+ 'post_status' => 'publish',
+ 'post_type' => 'post',
+ 'post_date' => {json.dumps(article['post_date'].strftime('%Y-%m-%d %H:%M:%S') if hasattr(article['post_date'], 'strftime') else str(article['post_date']), ensure_ascii=False)},
+]);
+if (is_wp_error($post_id)) {{ echo 'ERROR: ' . $post_id->get_error_message(); exit; }}
+
+// Asignar idioma Polylang
+if (function_exists('pll_set_post_language')) {{
+ pll_set_post_language($post_id, {json.dumps(lang_code)});
+}}
+
+// Vincular traducciones
+if (function_exists('pll_save_post_translations')) {{
+ $translations = pll_get_post_translations({original_id});
+ $translations[{json.dumps(lang_code)}] = $post_id;
+ $translations['es'] = {original_id};
+ pll_save_post_translations($translations);
+}}
+
+// Copiar categorías del original (excepto las de idioma)
+$cats = wp_get_post_categories({original_id}, ['fields' => 'ids']);
+if (!empty($cats)) wp_set_post_categories($post_id, $cats);
+
+echo 'CREATED:' . $post_id;
+"""
+
+ if dry_run:
+ print(f" [DRY] Crearía post '{translated_title[:60]}' en {lang_code}")
+ return 0
+
+ cmd = ["docker", "exec", WP_CONTAINER, "wp", "eval", php, "--allow-root"]
+ result = subprocess.run(cmd, capture_output=True, text=True)
+ output = result.stdout.strip()
+ if "CREATED:" in output:
+ new_id = int(output.split("CREATED:")[1].strip())
+ return new_id
+ else:
+ raise RuntimeError(f"Error creando post: {result.stdout} {result.stderr}")
+
+# ── Main ──────────────────────────────────────────────────────────────────────
+def main():
+ parser = argparse.ArgumentParser()
+ parser.add_argument("--check-api", action="store_true", help="Verificar conexión a Jan")
+ parser.add_argument("--dry-run", action="store_true", help="Simular sin crear posts")
+ parser.add_argument("--lang", help="Solo traducir a este idioma (en/fr/it/pt)")
+ parser.add_argument("--id", type=int, help="Solo traducir este WP ID")
+ args = parser.parse_args()
+
+ global JAN_MODEL
+ JAN_MODEL = get_jan_model()
+ print(f"Jan API OK — modelo: {JAN_MODEL}")
+
+ if args.check_api:
+ print("Probando traducción...")
+ t, c = translate("Prueba", "Hola mundo
", "en", "English")
+ print(f" Título: {t}")
+ print(f" Contenido: {c}")
+ return
+
+ langs = {args.lang: TARGET_LANGS[args.lang]} if args.lang else TARGET_LANGS
+ ids = [args.id] if args.id else SPANISH_IDS
+
+ db = get_db()
+ total = len(ids) * len(langs)
+ done = 0
+ skipped = 0
+ errors = 0
+
+ print(f"\nArtículos: {len(ids)} | Idiomas: {list(langs.keys())} | Total: {total} traducciones\n")
+
+ for wp_id in ids:
+ article = get_article(db, wp_id)
+ if not article:
+ print(f" ⚠ ID {wp_id} no encontrado, saltando")
+ continue
+
+ title = article['post_title']
+ content = article['post_content']
+ print(f"\n[{wp_id}] {title[:70]}")
+
+ if len(content) > MAX_CONTENT_LEN:
+ print(f" ⚠ Contenido demasiado largo ({len(content)} chars), saltando")
+ skipped += 1
+ continue
+
+ for lang_code, lang_name in langs.items():
+ existing = get_existing_translation(db, wp_id, lang_code)
+ if existing:
+ print(f" → {lang_code.upper()}: ya existe (ID {existing}), saltando")
+ skipped += 1
+ continue
+
+ try:
+ if args.dry_run:
+ print(f" → {lang_code.upper()}: [DRY] se traduciría y crearía post")
+ done += 1
+ continue
+
+ print(f" → {lang_code.upper()}: traduciendo... ", end="", flush=True)
+ t0 = time.time()
+ trans_title, trans_content = translate(title, content, lang_code, lang_name)
+ elapsed = time.time() - t0
+ print(f"{elapsed:.0f}s")
+ print(f" Título: {trans_title[:60]}")
+
+ new_id = create_wp_post(article, trans_title, trans_content, lang_code, wp_id, False)
+ print(f" Post creado: ID {new_id}")
+ done += 1
+
+ except Exception as e:
+ print(f" ERROR: {e}")
+ errors += 1
+ time.sleep(2)
+
+ db.close()
+ print(f"\n{'='*50}")
+ print(f"Completado: {done} creados, {skipped} saltados, {errors} errores")
+ if errors:
+ print("Puedes volver a ejecutar — los ya creados se saltarán automáticamente.")
+
+if __name__ == "__main__":
+ main()
diff --git a/scripts/translate_gap.sh b/scripts/translate_gap.sh
new file mode 100755
index 0000000..bbd12c0
--- /dev/null
+++ b/scripts/translate_gap.sh
@@ -0,0 +1,76 @@
+#!/usr/bin/env bash
+# ============================================================================
+# translate_gap.sh — Traduce el "gap" marzo→ahora de feadulta a EN/FR/IT/PT.
+#
+# Hace TODO de una vez: comprobaciones previas, traduce las 15 cartas semanales
+# (marzo a junio) + sus artículos con Gemma local, remapea categorías y enseña
+# el recuento final. Idempotente y REANUDABLE: re-ejecutar es seguro (salta lo
+# ya traducido). NO publica nada (todo queda en borrador / draft).
+#
+# USO (un solo comando, en segundo plano):
+# nohup bash scripts/translate_gap.sh > /tmp/feadulta-gap.out 2>&1 &
+# Y para ver el progreso:
+# tail -f /tmp/feadulta-gap.log
+#
+# Ver issue rafa/feadulta#75.
+# ============================================================================
+set -u
+
+cd "$(dirname "$0")/.." || { echo "No puedo entrar en el repo"; exit 1; }
+
+LOG=/tmp/feadulta-gap.log
+LANGS="en,fr,it,pt"
+# Cartas del gap (de más reciente a más antigua). Override opcional: CARTAS="45018" bash ...
+CARTAS="${CARTAS:-45018 44997 44975 44230 44229 44228 44090 44089 44088 44087 44086 44085 44084 44083 42590}"
+
+ts() { date '+%Y-%m-%d %H:%M:%S'; }
+say() { echo "[$(ts)] $*" | tee -a "$LOG"; }
+
+say "================ INICIO batch del gap (draft) ================"
+
+# 1) LM Studio + Gemma cargado
+say "Preflight 1/2: LM Studio / Gemma..."
+if ! curl -s --max-time 10 http://172.19.128.1:1234/v1/models 2>/dev/null | grep -q 'gemma-4-e4b'; then
+ say "ERROR: LM Studio no responde o 'google/gemma-4-e4b' no está cargado."
+ say " -> En Windows: abre LM Studio, carga 'google/gemma-4-e4b', server en 0.0.0.0:1234."
+ exit 1
+fi
+say " OK: Gemma disponible."
+
+# 2) Contenedores docker arriba
+say "Preflight 2/2: contenedores docker..."
+for cnt in wordpress-web wordpress-mysql; do
+ if ! docker ps --format '{{.Names}}' | grep -qx "$cnt"; then
+ say "ERROR: el contenedor '$cnt' no está arriba. Arranca el stack (docker compose up -d) y reintenta."
+ exit 1
+ fi
+done
+say " OK: wordpress-web y wordpress-mysql arriba."
+
+# 3) Traducir cada carta + sus artículos
+N=$(echo $CARTAS | wc -w)
+i=0
+for c in $CARTAS; do
+ i=$((i+1))
+ say "=== Carta $c ($i/$N) -> $LANGS (draft) ==="
+ python3 scripts/translate_post.py --carta "$c" --langs "$LANGS" --status draft 2>&1 | tee -a "$LOG"
+done
+
+# 4) Remap de categorías (idempotente, sin Gemma): mete cada traducción en la
+# categoría de su idioma (arregla el archivo de carta por idioma).
+say "Remapeando categorías de todas las traducciones..."
+docker cp scripts/remap_translation_cats.php wordpress-web:/tmp/remap_translation_cats.php >/dev/null 2>&1
+docker exec wordpress-web php /tmp/remap_translation_cats.php 2>&1 | tee -a "$LOG"
+
+# 5) Recuento final por idioma
+say "Recuento final de traducciones por idioma (meta traduccion_origen):"
+docker exec wordpress-mysql mysql -uwordpress_user -pwordpress_pass wordpress_db -N -e "
+SELECT t.slug, COUNT(*) FROM wp_postmeta m
+JOIN wp_term_relationships tr ON m.post_id=tr.object_id
+JOIN wp_term_taxonomy tt ON tr.term_taxonomy_id=tt.term_taxonomy_id AND tt.taxonomy='language'
+JOIN wp_terms t ON tt.term_id=t.term_id
+WHERE m.meta_key='traduccion_origen' GROUP BY t.slug;" 2>/dev/null | tee -a "$LOG"
+
+say "================ FIN batch del gap ================"
+say "Todo en DRAFT. No se ha publicado nada. Avisa a Rafa para revisar antes de publicar."
+say "Log completo: $LOG"
diff --git a/scripts/translate_haiku.py b/scripts/translate_haiku.py
new file mode 100644
index 0000000..ead8055
--- /dev/null
+++ b/scripts/translate_haiku.py
@@ -0,0 +1,87 @@
+#!/usr/bin/env python3
+"""Traduce ES->EN con Claude Haiku 4.5 vía API directa. Prueba de coste/calidad.
+
+Lee la ANTHROPIC_API_KEY de portfolio-tracker/.env (la misma que usa el
+portfolio tracker para trade setups). Reporta tokens reales de la API.
+"""
+import os
+import re
+import sys
+
+# Cargar API key del .env de portfolio-tracker sin pisar el entorno existente.
+ENV_PATH = "/home/rafa/portfolio-tracker/.env"
+if "ANTHROPIC_API_KEY" not in os.environ:
+ for line in open(ENV_PATH):
+ line = line.strip()
+ if line.startswith("ANTHROPIC_API_KEY="):
+ os.environ["ANTHROPIC_API_KEY"] = line.split("=", 1)[1].strip().strip('"').strip("'")
+ break
+
+import anthropic
+
+MODEL = "claude-haiku-4-5"
+
+LANG_NAMES = {"en": "English", "fr": "French (français)",
+ "it": "Italian (italiano)", "pt": "Portuguese (português)"}
+
+
+def system_prompt(lang: str) -> str:
+ target = LANG_NAMES[lang]
+ return (
+ f"Eres un traductor profesional de textos religiosos cristianos "
+ f"(espiritualidad y teología católica). Traduce del español al {target}. "
+ f"REGLAS ESTRICTAS:\n"
+ f"1. Conserva EXACTAMENTE el marcado HTML (etiquetas y atributos) y los "
+ f"shortcodes entre [ ] y {{ }}. No los traduzcas ni los reordenes.\n"
+ f"2. NO traduzcas las referencias bíblicas ni sus abreviaturas "
+ f"(p.ej. 'Jn 3, 16', 'Mt 5'). Déjalas idénticas.\n"
+ f"3. Conserva los nombres propios de persona y lugar (salvo exónimos establecidos).\n"
+ f"4. Términos litúrgicos correctos (p.ej. 'Cuaresma' = Lent/Carême/Quaresima/Quaresma; "
+ f"NO inventes palabras).\n"
+ f"5. Traducción FIEL: no resumas, no añadas, no comentes.\n"
+ f"6. Devuelve SOLO la traducción entre las marcas <<>> y <<>>, sin nada más."
+ )
+
+
+def extract(text: str) -> str:
+ # Coge el bloque <<>>...<<>> de contenido MÁS LARGO (robusto al
+ # bug del runner local, donde el modelo a veces re-menciona las marcas).
+ blocks = re.findall(r"<<>>(.*?)<<>>", text, re.S)
+ out = max(blocks, key=len).strip() if blocks else text.strip()
+ out = re.sub(r"^```[a-z]*\n?", "", out)
+ out = re.sub(r"\n?```$", "", out)
+ return out.strip()
+
+
+def translate(text: str, lang: str, *, is_title: bool = False) -> tuple[str, object]:
+ client = anthropic.Anthropic()
+ kind = "el TÍTULO" if is_title else "el texto"
+ user = (
+ f"Traduce {kind} que va entre las marcas. "
+ f"Debe quedar en {LANG_NAMES[lang]} de forma natural.\n"
+ f"<<>>{text}<<>>"
+ )
+ max_tokens = max(1024, int(len(text) * 0.9))
+ resp = client.messages.create(
+ model=MODEL,
+ max_tokens=min(max_tokens, 16000),
+ system=system_prompt(lang),
+ messages=[{"role": "user", "content": user}],
+ )
+ body = "".join(b.text for b in resp.content if b.type == "text")
+ return extract(body), resp.usage
+
+
+if __name__ == "__main__":
+ path = sys.argv[1] if len(sys.argv) > 1 else "/tmp/orig_es.html"
+ lang = sys.argv[2] if len(sys.argv) > 2 else "en"
+ src = open(path).read()
+ out, usage = translate(src, lang)
+ open("/tmp/trad_haiku.html", "w").write(out)
+ cost = usage.input_tokens / 1e6 * 1.0 + usage.output_tokens / 1e6 * 5.0
+ print(f"MODEL={MODEL} lang={lang}")
+ print(f"input_tokens={usage.input_tokens} output_tokens={usage.output_tokens}")
+ print(f"coste_articulo=${cost:.5f}")
+ print(f"chars_in={len(src)} chars_out={len(out)}")
+ print("--- primeras 500 car ---")
+ print(out[:500])
diff --git a/scripts/translate_lectura_titles.php b/scripts/translate_lectura_titles.php
new file mode 100644
index 0000000..1316f24
--- /dev/null
+++ b/scripts/translate_lectura_titles.php
@@ -0,0 +1,218 @@
+ , ...».
+ * El cuerpo ya está traducido; esto es title-only.
+ *
+ * - Determinista: mapa fijo de libros ES -> {en,fr,it,pt}.
+ * - Idempotente: si el token inicial ya está en el idioma destino, no toca nada.
+ * - Seguro: exige número tras el libro (excluye «Juan Pablo II», «Domingo 30...»,
+ * etc. — DOMINGO/SEMANA no son libros, no están en el mapa).
+ * - Cotejo insensible a acentos (fold a ASCII-mayúsculas) para casar variantes;
+ * el valor canónico por idioma garantiza que ES==destino sea un no-op.
+ *
+ * Uso (local): docker exec wordpress-web php /var/www/html/scripts/... (o vía cwd)
+ * php scripts/translate_lectura_titles.php # dry-run + reporte
+ * APPLY=1 php scripts/translate_lectura_titles.php # aplica
+ * Prod: FEA_WP_LOAD=/web/wp-nuevo/wp-load.php php translate_lectura_titles.php
+ */
+
+error_reporting(E_ALL & ~E_DEPRECATED & ~E_NOTICE);
+
+$WP_LOAD = getenv('FEA_WP_LOAD') ?: '/var/www/html/wp-load.php';
+if (!file_exists($WP_LOAD)) {
+ fwrite(STDERR, "No encuentro wp-load.php en $WP_LOAD\n");
+ exit(1);
+}
+define('WP_USE_THEMES', false);
+require $WP_LOAD;
+
+global $wpdb;
+$APPLY = getenv('APPLY') === '1';
+$LANGS = ['en', 'fr', 'it', 'pt'];
+
+/*
+ * Mapa de libros: clave en español (display) => [en, fr, it, pt] (Title case canónico).
+ * El cotejo es accent-insensitive; los valores destino son los litúrgicos católicos.
+ */
+$BOOKS = [
+ // --- Antiguo Testamento ---
+ 'Génesis' => ['Genesis', 'Genèse', 'Genesi', 'Gênesis'],
+ 'Éxodo' => ['Exodus', 'Exode', 'Esodo', 'Êxodo'],
+ 'Levítico' => ['Leviticus', 'Lévitique', 'Levitico', 'Levítico'],
+ 'Números' => ['Numbers', 'Nombres', 'Numeri', 'Números'],
+ 'Deuteronomio' => ['Deuteronomy', 'Deutéronome', 'Deuteronomio', 'Deuteronômio'],
+ 'Josué' => ['Joshua', 'Josué', 'Giosuè', 'Josué'],
+ 'Jueces' => ['Judges', 'Juges', 'Giudici', 'Juízes'],
+ 'Rut' => ['Ruth', 'Ruth', 'Rut', 'Rute'],
+ 'Samuel' => ['Samuel', 'Samuel', 'Samuele', 'Samuel'],
+ 'Reyes' => ['Kings', 'Rois', 'Re', 'Reis'],
+ 'Crónicas' => ['Chronicles', 'Chroniques', 'Cronache', 'Crônicas'],
+ 'Esdras' => ['Ezra', 'Esdras', 'Esdra', 'Esdras'],
+ 'Nehemías' => ['Nehemiah', 'Néhémie', 'Neemia', 'Neemias'],
+ 'Tobías' => ['Tobit', 'Tobie', 'Tobia', 'Tobias'],
+ 'Judit' => ['Judith', 'Judith', 'Giuditta', 'Judite'],
+ 'Ester' => ['Esther', 'Esther', 'Ester', 'Ester'],
+ 'Macabeos' => ['Maccabees', 'Maccabées', 'Maccabei', 'Macabeus'],
+ 'Job' => ['Job', 'Job', 'Giobbe', 'Jó'],
+ 'Salmos' => ['Psalms', 'Psaumes', 'Salmi', 'Salmos'],
+ 'Salmo' => ['Psalm', 'Psaume', 'Salmo', 'Salmo'],
+ 'Proverbios' => ['Proverbs', 'Proverbes', 'Proverbi', 'Provérbios'],
+ 'Eclesiastés' => ['Ecclesiastes', 'Ecclésiaste', 'Ecclesiaste', 'Eclesiastes'],
+ 'Eclesiástico' => ['Ecclesiasticus', 'Siracide', 'Siracide', 'Eclesiástico'],
+ 'Sabiduría' => ['Wisdom', 'Sagesse', 'Sapienza', 'Sabedoria'],
+ 'Isaías' => ['Isaiah', 'Isaïe', 'Isaia', 'Isaías'],
+ 'Jeremías' => ['Jeremiah', 'Jérémie', 'Geremia', 'Jeremias'],
+ 'Lamentaciones' => ['Lamentations', 'Lamentations', 'Lamentazioni', 'Lamentações'],
+ 'Baruc' => ['Baruch', 'Baruch', 'Baruc', 'Baruc'],
+ 'Ezequiel' => ['Ezekiel', 'Ézéchiel', 'Ezechiele', 'Ezequiel'],
+ 'Daniel' => ['Daniel', 'Daniel', 'Daniele', 'Daniel'],
+ 'Oseas' => ['Hosea', 'Osée', 'Osea', 'Oseias'],
+ 'Joel' => ['Joel', 'Joël', 'Gioele', 'Joel'],
+ 'Amós' => ['Amos', 'Amos', 'Amos', 'Amós'],
+ 'Abdías' => ['Obadiah', 'Abdias', 'Abdia', 'Abdias'],
+ 'Jonás' => ['Jonah', 'Jonas', 'Giona', 'Jonas'],
+ 'Miqueas' => ['Micah', 'Michée', 'Michea', 'Miqueias'],
+ 'Nahúm' => ['Nahum', 'Nahum', 'Naum', 'Naum'],
+ 'Habacuc' => ['Habakkuk', 'Habacuc', 'Abacuc', 'Habacuc'],
+ 'Sofonías' => ['Zephaniah', 'Sophonie', 'Sofonia', 'Sofonias'],
+ 'Ageo' => ['Haggai', 'Aggée', 'Aggeo', 'Ageu'],
+ 'Zacarías' => ['Zechariah', 'Zacharie', 'Zaccaria', 'Zacarias'],
+ 'Malaquías' => ['Malachi', 'Malachie', 'Malachia', 'Malaquias'],
+ // --- Nuevo Testamento ---
+ 'Mateo' => ['Matthew', 'Matthieu', 'Matteo', 'Mateus'],
+ 'Marcos' => ['Mark', 'Marc', 'Marco', 'Marcos'],
+ 'Lucas' => ['Luke', 'Luc', 'Luca', 'Lucas'],
+ 'Juan' => ['John', 'Jean', 'Giovanni', 'João'],
+ 'Hechos' => ['Acts', 'Actes', 'Atti', 'Atos'],
+ 'Romanos' => ['Romans', 'Romains', 'Romani', 'Romanos'],
+ 'Corintios' => ['Corinthians', 'Corinthiens', 'Corinzi', 'Coríntios'],
+ 'Gálatas' => ['Galatians', 'Galates', 'Galati', 'Gálatas'],
+ 'Efesios' => ['Ephesians', 'Éphésiens', 'Efesini', 'Efésios'],
+ 'Filipenses' => ['Philippians', 'Philippiens', 'Filippesi', 'Filipenses'],
+ 'Colosenses' => ['Colossians', 'Colossiens', 'Colossesi', 'Colossenses'],
+ 'Tesalonicenses' => ['Thessalonians', 'Thessaloniciens', 'Tessalonicesi', 'Tessalonicenses'],
+ 'Timoteo' => ['Timothy', 'Timothée', 'Timoteo', 'Timóteo'],
+ 'Tito' => ['Titus', 'Tite', 'Tito', 'Tito'],
+ 'Filemón' => ['Philemon', 'Philémon', 'Filemone', 'Filêmon'],
+ 'Hebreos' => ['Hebrews', 'Hébreux', 'Ebrei', 'Hebreus'],
+ 'Santiago' => ['James', 'Jacques', 'Giacomo', 'Tiago'],
+ 'Pedro' => ['Peter', 'Pierre', 'Pietro', 'Pedro'],
+ 'Judas' => ['Jude', 'Jude', 'Giuda', 'Judas'],
+ 'Apocalipsis' => ['Revelation', 'Apocalypse', 'Apocalisse', 'Apocalipse'],
+];
+
+// fold a ASCII-mayúsculas (quita acentos) para cotejo robusto
+function fold($s) {
+ $s = trim($s);
+ $map = ['Á'=>'A','À'=>'A','Ä'=>'A','Â'=>'A','Ã'=>'A','É'=>'E','È'=>'E','Ë'=>'E','Ê'=>'E',
+ 'Í'=>'I','Ì'=>'I','Ï'=>'I','Î'=>'I','Ó'=>'O','Ò'=>'O','Ö'=>'O','Ô'=>'O','Õ'=>'O',
+ 'Ú'=>'U','Ù'=>'U','Ü'=>'U','Û'=>'U','Ñ'=>'N','Ç'=>'C'];
+ $s = mb_strtoupper($s, 'UTF-8');
+ return strtr($s, $map);
+}
+
+$langIdx = array_flip($LANGS); // en=>0,...
+// índice de búsqueda: foldedSpanish => [en,fr,it,pt]
+$LOOKUP = [];
+foreach ($BOOKS as $es => $tr) {
+ $LOOKUP[fold($es)] = $tr;
+}
+
+// Todos los posts no-ES (filtramos/transformamos en PHP, regex /u fiable).
+$placeholders = implode(',', array_fill(0, count($LANGS), '%s'));
+$sql = $wpdb->prepare(
+ "SELECT p.ID, t.slug AS lang, p.post_title
+ FROM {$wpdb->posts} p
+ JOIN {$wpdb->term_relationships} tr ON tr.object_id = p.ID
+ JOIN {$wpdb->term_taxonomy} tt ON tt.term_taxonomy_id = tr.term_taxonomy_id AND tt.taxonomy='language'
+ JOIN {$wpdb->terms} t ON t.term_id = tt.term_id
+ WHERE p.post_type='post'
+ AND p.post_status IN ('publish','draft','future','pending','private')
+ AND t.slug IN ($placeholders)",
+ $LANGS
+);
+$rows = $wpdb->get_results($sql);
+
+$changes = []; // [ID => [lang, old, new]]
+$per_lang = array_fill_keys($LANGS, 0);
+$skipped_already = 0;
+$candidates = 0; // títulos con al menos una cita bíblica detectada
+
+/*
+ * Traduce CADA token de libro de una cita bíblica dentro del título:
+ * - una palabra (letras) NO precedida por letra/número
+ * - seguida de «» (el capítulo de la cita).
+ * Cubre el inicio, los compuestos «1ª lectura / 2ª lectura / evangelio» (tras «/»),
+ * el ordinal previo («2 Timoteo 4») y prefijos de fiesta («Epifanía - Isaías 60»).
+ * Como SOLO casa ortografías españolas (las del mapa), en posts no-ES únicamente
+ * toca citas heredadas del ES; las descripciones van en el idioma destino.
+ */
+$BOOK_RE = '/(?lang;
+ $li = $langIdx[$lang];
+ $hit = false;
+ $new_title = preg_replace_callback($BOOK_RE, function ($m) use ($LOOKUP, $li, &$hit) {
+ $book = $m[1];
+ $key = fold($book);
+ if (!isset($LOOKUP[$key])) {
+ return $m[0]; // no es libro conocido -> intacto
+ }
+ $hit = true;
+ $canon = $LOOKUP[$key][$li];
+ $isUpper = (mb_strtoupper($book, 'UTF-8') === $book);
+ return $isUpper ? mb_strtoupper($canon, 'UTF-8') : $canon;
+ }, $r->post_title);
+
+ if (!$hit) { continue; }
+ $candidates++;
+ if ($new_title === $r->post_title) { $skipped_already++; continue; } // idempotente
+
+ $changes[$r->ID] = [$lang, $r->post_title, $new_title];
+ $per_lang[$lang]++;
+}
+
+// --- Reporte ---
+echo "== translate_lectura_titles.php (issue #140) ==\n";
+echo "WP_LOAD: $WP_LOAD\n";
+echo "Posts no-ES escaneados: " . count($rows) . "\n";
+echo " - con cita bíblica detectada: $candidates\n";
+echo " - ya en idioma destino (idempotente): $skipped_already\n";
+echo " - A CAMBIAR: " . count($changes) . "\n";
+echo " por idioma: ";
+foreach ($LANGS as $l) echo strtoupper($l) . "=" . $per_lang[$l] . " ";
+echo "\n\n";
+
+$SAMPLE = (int)(getenv('SAMPLE') ?: 8);
+foreach ($LANGS as $l) {
+ $shown = 0;
+ echo "--- muestra $l ---\n";
+ foreach ($changes as $id => $c) {
+ if ($c[0] !== $l) continue;
+ echo sprintf(" %d «%s» -> «%s»\n", $id, $c[1], $c[2]);
+ if ($SAMPLE > 0 && ++$shown >= $SAMPLE) break;
+ }
+}
+echo "\n";
+
+if (!$APPLY) {
+ echo "DRY-RUN (no se ha tocado nada). Ejecuta con APPLY=1 para aplicar.\n";
+ exit(0);
+}
+
+// --- Aplica (title-only, sin tocar slug/cuerpo) ---
+$done = 0;
+foreach ($changes as $id => $c) {
+ $ok = $wpdb->update($wpdb->posts, ['post_title' => $c[2]], ['ID' => $id], ['%s'], ['%d']);
+ if ($ok !== false) {
+ clean_post_cache($id);
+ $done++;
+ } else {
+ fwrite(STDERR, "ERROR al actualizar ID $id\n");
+ }
+}
+echo "APLICADOS: $done de " . count($changes) . "\n";
diff --git a/scripts/translate_post.py b/scripts/translate_post.py
new file mode 100644
index 0000000..4fe17b6
--- /dev/null
+++ b/scripts/translate_post.py
@@ -0,0 +1,340 @@
+#!/usr/bin/env python3
+"""
+translate_post.py — Traduce posts de feadulta (ES → EN/FR/IT/PT) con Gemma 4B local
+y los enlaza como traducciones de Polylang, SIN servicios de pago.
+
+Diseño (issue rafa/feadulta#75, fase 1):
+- Gemma (LM Studio, http://172.19.128.1:1234/v1) traduce título + contenido HTML.
+- Reglas estrictas: preserva HTML/shortcodes, NO traduce referencias bíblicas, respeta
+ nombres propios y un glosario fijo del proyecto. Traducción fiel (sin resumir).
+- La lógica WordPress/Polylang vive en fea_translate_helper.php (corre dentro del
+ contenedor cargando wp-load.php; no necesita wp-cli ni proc_open).
+- Idempotente y reanudable: si ya existe la traducción en ese idioma, se salta.
+
+Uso:
+ python3 scripts/translate_post.py --post-id 45018 --langs en,fr,it,pt
+ python3 scripts/translate_post.py --carta 45018 # carta + sus _carta_id
+ python3 scripts/translate_post.py --post-id 45018 --langs en --status publish --force
+
+Pensado para que Codex lo lance en lote sobre la cola priorizada (cartas/destacados).
+"""
+
+from __future__ import annotations
+
+import argparse
+import fcntl
+import json
+import os
+import re
+import subprocess
+import sys
+import time
+from pathlib import Path
+
+# ── Configuración ────────────────────────────────────────────────────────────
+WP_CONTAINER = os.environ.get("FEA_WP_CONTAINER", "wordpress-web")
+DB_CONTAINER = os.environ.get("FEA_DB_CONTAINER", "wordpress-mysql")
+DB_NAME = os.environ.get("FEA_DB_NAME", "wordpress_db")
+DB_USER = os.environ.get("FEA_DB_USER", "wordpress_user")
+DB_PASS = os.environ.get("FEA_DB_PASS", "wordpress_pass")
+
+LM_BASE_URL = os.environ.get("OPENAI_BASE_URL", "http://172.19.128.1:1234/v1")
+MODEL = os.environ.get("LOCAL_MODEL", "google/gemma-4-e4b")
+
+# Motor de traducción: "gemma" (local, por defecto) o "haiku" (Claude Haiku 4.5 vía API).
+# Haiku da más calidad y no necesita trocear (contexto 200k). Reutiliza translate_haiku.py.
+ENGINE = os.environ.get("FEA_ENGINE", "gemma").lower()
+if ENGINE == "haiku":
+ MODEL = "claude-haiku-4-5"
+ sys.path.insert(0, str(Path(__file__).resolve().parent))
+ import translate_haiku # carga la API key de portfolio-tracker/.env
+elif ENGINE == "minimax":
+ MODEL = os.environ.get("LOCAL_MODEL", "MiniMax-Text-01")
+ MINIMAX_URL = os.environ.get("MINIMAX_URL", "https://api.minimax.io/v1/text/chatcompletion_v2")
+ _kf = Path(os.environ.get("MINIMAX_KEY_FILE", "/home/rafa/Feadulta/minimax.txt"))
+ _keys = [l.strip() for l in _kf.read_text().splitlines() if l.strip().startswith("sk-")]
+ MINIMAX_KEY = _keys[-1] if _keys else ""
+
+HELPER_SRC = Path(__file__).resolve().parent / "fea_translate_helper.php"
+HELPER_DST = "/tmp/fea_translate_helper.php"
+STATE_FILE = Path(os.environ.get("FEA_TR_STATE", "/tmp/feadulta-translate-state.json"))
+LOG_FILE = Path(os.environ.get("FEA_TR_LOG", "/tmp/feadulta-translate.log"))
+
+LANG_NAMES = {"en": "English", "fr": "French (français)", "it": "Italian (italiano)", "pt": "Portuguese (português)"}
+
+# Glosario: términos que NO se traducen o se fijan.
+GLOSSARY = {
+ "Fe Adulta": {"en": "Fe Adulta", "fr": "Fe Adulta", "it": "Fe Adulta", "pt": "Fe Adulta"},
+ "EFFA": {"en": "EFFA", "fr": "EFFA", "it": "EFFA", "pt": "EFFA"},
+}
+
+CHUNK_LIMIT = 5000 # caracteres por llamada a Gemma (parte por si se supera)
+
+
+# ── Utilidades de proceso ────────────────────────────────────────────────────
+def log(msg: str) -> None:
+ line = f"[{time.strftime('%Y-%m-%d %H:%M:%S')}] {msg}"
+ print(line, flush=True)
+ try:
+ LOG_FILE.open("a", encoding="utf-8").write(line + "\n")
+ except OSError:
+ pass
+
+
+def sh(cmd: list[str], *, stdin: str | None = None, timeout: int = 120) -> str:
+ r = subprocess.run(cmd, input=stdin, capture_output=True, text=True, timeout=timeout)
+ if r.returncode != 0:
+ raise RuntimeError(f"cmd falló ({r.returncode}): {' '.join(cmd)}\n{r.stderr.strip()}")
+ return r.stdout
+
+
+_helper_ready = False
+
+
+def php_helper(subcmd: str, *args: str, stdin: str | None = None) -> str:
+ """Copia el helper al contenedor (una vez) y lo ejecuta cargando wp-load.php."""
+ global _helper_ready
+ if not _helper_ready:
+ sh(["docker", "cp", str(HELPER_SRC), f"{WP_CONTAINER}:{HELPER_DST}"])
+ _helper_ready = True
+ cmd = ["docker", "exec", "-i", WP_CONTAINER, "php", HELPER_DST, subcmd, *args]
+ return sh(cmd, stdin=stdin, timeout=180)
+
+
+# ── Gemma (LM Studio) ────────────────────────────────────────────────────────
+def gemma(messages: list[dict], *, max_tokens: int) -> str:
+ import urllib.request
+
+ body = json.dumps({
+ "model": MODEL,
+ "messages": messages,
+ "temperature": 0.2,
+ "max_tokens": max_tokens,
+ "reasoning_effort": "none",
+ }).encode("utf-8")
+ req = urllib.request.Request(
+ f"{LM_BASE_URL}/chat/completions", data=body,
+ headers={"Content-Type": "application/json"},
+ )
+ with urllib.request.urlopen(req, timeout=300) as resp:
+ data = json.loads(resp.read().decode("utf-8"))
+ return data["choices"][0]["message"]["content"]
+
+
+def minimax(messages: list[dict], *, max_tokens: int) -> str:
+ import urllib.request
+
+ body = json.dumps({
+ "model": MODEL,
+ "messages": messages,
+ "temperature": 0.2,
+ "max_tokens": max_tokens,
+ }).encode("utf-8")
+ req = urllib.request.Request(
+ MINIMAX_URL, data=body,
+ headers={"Content-Type": "application/json", "Authorization": f"Bearer {MINIMAX_KEY}"},
+ )
+ with urllib.request.urlopen(req, timeout=300) as resp:
+ data = json.loads(resp.read().decode("utf-8"))
+ return data["choices"][0]["message"]["content"]
+
+
+def _extract(text: str) -> str:
+ """Extrae la traducción del ÚLTIMO bloque <<>>…<<>>.
+
+ Gemma (modo reasoning) escribe un preámbulo que MENCIONA las propias marcas,
+ así que hay que quedarse con la última ocurrencia, no la primera.
+ """
+ start_tok, end_tok = "<<>>", "<<>>"
+ i = text.rfind(start_tok)
+ if i != -1:
+ rest = text[i + len(start_tok):]
+ j = rest.find(end_tok)
+ out = (rest[:j] if j != -1 else rest).strip()
+ else:
+ out = text.strip()
+ # Quita vallas de código markdown si Gemma las añade.
+ out = re.sub(r"^```[a-z]*\n?", "", out)
+ out = re.sub(r"\n?```$", "", out)
+ return out.strip()
+
+
+def _system_prompt(lang: str) -> str:
+ target = LANG_NAMES[lang]
+ glos = "; ".join(f'"{k}" → "{v[lang]}"' for k, v in GLOSSARY.items())
+ return (
+ f"Eres un traductor profesional de textos religiosos cristianos (espiritualidad y "
+ f"teología católica). Traduce del español al {target}. REGLAS ESTRICTAS:\n"
+ f"1. Conserva EXACTAMENTE el marcado HTML (etiquetas y atributos) y los shortcodes "
+ f"entre [ ] y { '{' } { '}' }. No los traduzcas ni los reordenes.\n"
+ f"2. NO traduzcas las referencias bíblicas ni sus abreviaturas (p.ej. 'Jn 3, 16', "
+ f"'Isaías 5, 1-7', 'Mt 5'). Déjalas idénticas.\n"
+ f"3. Conserva los nombres propios de persona y lugar (salvo exónimos establecidos).\n"
+ f"4. Glosario fijo: {glos}.\n"
+ f"5. Traducción FIEL: no resumas, no añadas, no comentes.\n"
+ f"6. Devuelve SOLO la traducción entre las marcas <<>> y <<>>, sin nada más."
+ )
+
+
+def translate_text(text: str, lang: str, *, is_title: bool = False) -> str:
+ text = text.strip()
+ if not text:
+ return ""
+ if ENGINE == "haiku":
+ out, _usage = translate_haiku.translate(text, lang, is_title=is_title)
+ return out
+ user = f"<<>>{text}<<>>"
+ if is_title:
+ kind = "el TÍTULO"
+ task = (
+ f"Traduce {kind} que va entre las marcas.\n"
+ f"Debe quedar en {LANG_NAMES[lang]} de forma natural. "
+ f"No lo dejes en inglés salvo que el original ya sea un nombre propio o una marca.\n"
+ f"Responde solo con el título traducido entre las marcas:\n{user}"
+ )
+ else:
+ kind = "el texto"
+ task = f"Traduce {kind} que va entre las marcas:\n{user}"
+ messages = [
+ {"role": "system", "content": _system_prompt(lang)},
+ {"role": "user", "content": task},
+ ]
+ max_tokens = max(800, int(len(text) * 1.6))
+ engine_fn = minimax if ENGINE == "minimax" else gemma
+ raw = engine_fn(messages, max_tokens=max_tokens)
+ return _extract(raw)
+
+
+def translate_html(html: str, lang: str) -> str:
+ """Trocea por párrafos si el contenido es largo, para no saturar el contexto de Gemma."""
+ if ENGINE == "haiku":
+ # Haiku tiene 200k de contexto: el artículo entero de una vez (mejor coherencia).
+ return translate_text(html, lang)
+ if len(html) <= CHUNK_LIMIT:
+ return translate_text(html, lang)
+ parts = re.split(r"(?<=)", html)
+ chunks, buf = [], ""
+ for p in parts:
+ if len(buf) + len(p) > CHUNK_LIMIT and buf:
+ chunks.append(buf)
+ buf = ""
+ buf += p
+ if buf:
+ chunks.append(buf)
+ log(f" contenido largo ({len(html)} car) → {len(chunks)} trozos")
+ return "".join(translate_text(c, lang) for c in chunks)
+
+
+# ── Datos / estado ───────────────────────────────────────────────────────────
+def read_post(post_id: int) -> dict:
+ return json.loads(php_helper("read", str(post_id)))
+
+
+def translation_exists(es_id: int, lang: str) -> int:
+ return int(php_helper("exists", str(es_id), lang).strip() or "0")
+
+
+WP_LOCK_FILE = Path(os.environ.get("FEA_TR_LOCK", "/tmp/feadulta-translate.lock"))
+
+
+def create_translation(es_id: int, lang: str, title: str, content: str, status: str) -> int:
+ payload = json.dumps({"title": title, "content": content, "model": MODEL})
+ # Lock entre procesos: serializa SOLO la escritura/enlace Polylang (rápido), no la
+ # traducción LLM (lenta), para que 4 streams por idioma no pisen el grupo de traducciones.
+ with WP_LOCK_FILE.open("w") as lk:
+ fcntl.flock(lk, fcntl.LOCK_EX)
+ try:
+ return int(php_helper("create", str(es_id), lang, status, stdin=payload).strip())
+ finally:
+ fcntl.flock(lk, fcntl.LOCK_UN)
+
+
+def carta_article_ids(carta_id: int) -> list[int]:
+ q = (f"SELECT post_id FROM wp_postmeta WHERE meta_key='_carta_id' "
+ f"AND meta_value='{carta_id}' ORDER BY post_id;")
+ out = sh(["docker", "exec", DB_CONTAINER, "mysql", f"-u{DB_USER}", f"-p{DB_PASS}",
+ DB_NAME, "-N", "-e", q])
+ return [int(x) for x in out.split() if x.strip().isdigit()]
+
+
+def load_state() -> dict:
+ if STATE_FILE.exists():
+ try:
+ return json.loads(STATE_FILE.read_text())
+ except json.JSONDecodeError:
+ pass
+ return {"done": {}}
+
+
+def save_state(state: dict) -> None:
+ STATE_FILE.write_text(json.dumps(state, ensure_ascii=False, indent=2))
+
+
+# ── Orquestación ─────────────────────────────────────────────────────────────
+def process_post(post_id: int, langs: list[str], status: str, force: bool, state: dict) -> None:
+ src = read_post(post_id)
+ if src.get("lang") and src["lang"] != "es":
+ log(f"#{post_id} no es ES (lang={src['lang']}) — saltado")
+ return
+ log(f"#{post_id} «{src['title'][:60]}»")
+
+ for lang in langs:
+ key = f"{post_id}:{lang}"
+ existing = translation_exists(post_id, lang)
+ if existing and not force:
+ log(f" {lang}: ya existe (#{existing}) — saltado")
+ state["done"][key] = existing
+ continue
+ if existing and force:
+ php_helper("unlink", str(post_id), lang)
+ log(f" {lang}: --force, eliminada traducción previa #{existing}")
+ try:
+ t0 = time.time()
+ title = translate_text(src["title"], lang, is_title=True)
+ content = translate_html(src["content"], lang)
+ new_id = create_translation(post_id, lang, title, content, status)
+ dt = time.time() - t0
+ log(f" {lang}: creado #{new_id} ({dt:.0f}s) → «{title[:50]}»")
+ state["done"][key] = new_id
+ save_state(state)
+ except Exception as exc: # noqa: BLE001
+ log(f" {lang}: ERROR {exc}")
+ state.setdefault("errors", {})[key] = str(exc)
+ save_state(state)
+
+
+def main() -> int:
+ ap = argparse.ArgumentParser(description="Traduce posts de feadulta con Gemma local + Polylang.")
+ g = ap.add_mutually_exclusive_group(required=True)
+ g.add_argument("--post-id", type=int, help="ID de un post ES a traducir.")
+ g.add_argument("--carta", type=int, help="ID de carta: traduce la carta y todos sus artículos (_carta_id).")
+ g.add_argument("--ids-file", help="Fichero con un ID de post ES por línea.")
+ ap.add_argument("--langs", default="en,fr,it,pt", help="Idiomas destino separados por coma.")
+ ap.add_argument("--status", default="draft", choices=["draft", "publish"], help="Estado de la traducción.")
+ ap.add_argument("--force", action="store_true", help="Regenera aunque ya exista la traducción.")
+ args = ap.parse_args()
+
+ langs = [l.strip() for l in args.langs.split(",") if l.strip() in LANG_NAMES]
+ if not langs:
+ log("Sin idiomas válidos."); return 1
+
+ if args.post_id:
+ ids = [args.post_id]
+ elif args.ids_file:
+ ids = [int(x) for x in Path(args.ids_file).read_text().split() if x.strip().isdigit()]
+ log(f"ids-file {args.ids_file}: {len(ids)} posts")
+ else:
+ ids = [args.carta] + carta_article_ids(args.carta)
+ log(f"Carta {args.carta}: {len(ids)} posts (carta + {len(ids)-1} artículos)")
+
+ state = load_state()
+ for pid in ids:
+ process_post(pid, langs, args.status, args.force, state)
+ save_state(state)
+ log(f"FIN. {len(state['done'])} traducciones registradas, "
+ f"{len(state.get('errors', {}))} errores. Estado: {STATE_FILE}")
+ return 0
+
+
+if __name__ == "__main__":
+ raise SystemExit(main())
diff --git a/scripts/tts_carta.py b/scripts/tts_carta.py
new file mode 100644
index 0000000..bcbbf43
--- /dev/null
+++ b/scripts/tts_carta.py
@@ -0,0 +1,99 @@
+#!/usr/bin/env python3
+"""Locuta una carta/artículo entero de feadulta con la voz clonada (XTTS-v2 + GPU).
+
+Saca el texto del post ES, lo trocea por párrafos, lo locuta con la voz de
+referencia (calculando los latents del hablante UNA sola vez), concatena con
+pausas y añade comfort noise. Issue #76.
+
+Uso:
+ tts_carta.py [nombre_salida]
+"""
+import html
+import json
+import os
+import re
+import subprocess
+import sys
+from pathlib import Path
+
+os.environ.setdefault("COQUI_TOS_AGREED", "1")
+
+import numpy as np # noqa: E402
+import soundfile as sf # noqa: E402
+import torch # noqa: E402
+from TTS.api import TTS # noqa: E402
+
+DEVICE = "cuda" if torch.cuda.is_available() and not os.environ.get("FEA_CPU") else "cpu"
+OUT = Path(__file__).resolve().parent.parent / "wordpress/wp-content/uploads/tts-samples"
+SR = 24000
+CONTAINER = "wordpress-web"
+
+
+def get_post_text(pid):
+ subprocess.run(["docker", "exec", CONTAINER, "php", "/tmp/fea_post_io.php", "get", str(pid)],
+ check=True, capture_output=True)
+ subprocess.run(["docker", "cp", f"{CONTAINER}:/tmp/fea_es.json", "/tmp/fea_es.json"], check=True)
+ d = json.load(open("/tmp/fea_es.json"))
+ raw = d["content"]
+ # Conserva límites de párrafo antes de quitar tags.
+ raw = re.sub(r"(?i)||", "\n", raw)
+ raw = re.sub(r"<[^>]+>", "", raw) # quita tags
+ raw = re.sub(r"\[[^\]]+\]", "", raw) # quita shortcodes
+ raw = html.unescape(raw)
+ paras = [re.sub(r"\s+", " ", p).strip() for p in raw.split("\n")]
+ paras = [p for p in paras if len(p) > 1]
+ return d["title"], paras
+
+
+def main():
+ if len(sys.argv) < 3:
+ sys.exit("uso: tts_carta.py [nombre_salida]")
+ pid = int(sys.argv[1])
+ spk = sys.argv[2]
+ name = sys.argv[3] if len(sys.argv) > 3 else f"carta-{pid}"
+
+ title, paras = get_post_text(pid)
+ print(f"Post #{pid}: «{title}» ({len(paras)} párrafos, {sum(len(p) for p in paras)} car)")
+
+ print(f"Cargando XTTS-v2 en {DEVICE}…", flush=True)
+ tts = TTS("tts_models/multilingual/multi-dataset/xtts_v2").to(DEVICE)
+ model = tts.synthesizer.tts_model
+ print("Calculando timbre del hablante (1 vez)…", flush=True)
+ gpt_cond, spk_emb = model.get_conditioning_latents(audio_path=[spk])
+
+ pause = np.zeros(int(SR * 0.35), dtype=np.float32)
+ pieces = []
+ import time
+ t0 = time.time()
+ for i, para in enumerate(paras, 1):
+ out = model.inference(
+ para, "es", gpt_cond, spk_emb,
+ temperature=0.65, repetition_penalty=5.0, top_k=50, top_p=0.85,
+ enable_text_splitting=True,
+ )
+ pieces.append(np.asarray(out["wav"], dtype=np.float32))
+ pieces.append(pause)
+ print(f" párrafo {i}/{len(paras)} ({len(para)} car) ok", flush=True)
+ audio = np.concatenate(pieces)
+ dt = time.time() - t0
+ dur = len(audio) / SR
+ print(f"Síntesis: {dt:.1f}s para {dur:.1f}s de audio (x{dur/dt:.1f} tiempo real) en {DEVICE}")
+
+ raw = OUT / f"{name}.raw.wav"
+ sf.write(raw, audio, SR)
+ wav = OUT / f"{name}.wav"
+ subprocess.run([
+ "ffmpeg", "-y", "-i", str(raw), "-filter_complex",
+ "anoisesrc=color=brown:amplitude=0.004:sample_rate=24000[n];"
+ "[n]highpass=f=120,lowpass=f=3800[nf];"
+ "[0:a][nf]amix=inputs=2:duration=first:dropout_transition=0:normalize=0[a]",
+ "-map", "[a]", "-ar", "24000", str(wav),
+ ], capture_output=True)
+ raw.unlink(missing_ok=True)
+ mp3 = OUT / f"{name}.mp3"
+ subprocess.run(["ffmpeg", "-y", "-i", str(wav), "-b:a", "96k", str(mp3)], capture_output=True)
+ print(f"OK -> {mp3} ({dur:.0f}s de audio)")
+
+
+if __name__ == "__main__":
+ main()
diff --git a/scripts/tts_carta_edge.py b/scripts/tts_carta_edge.py
new file mode 100644
index 0000000..9a2d1ed
--- /dev/null
+++ b/scripts/tts_carta_edge.py
@@ -0,0 +1,51 @@
+#!/usr/bin/env python3
+"""Locuta una carta entera con edge-tts (online, gratis). Para comparar con XTTS.
+
+Uso: tts_carta_edge.py [voz] [nombre_salida]
+voz por defecto: es-ES-XimenaNeural
+"""
+import html
+import json
+import os
+import re
+import subprocess
+import sys
+from pathlib import Path
+
+EDGE = os.path.expanduser("~/.hermes/hermes-agent/venv/bin/edge-tts")
+OUT = Path(__file__).resolve().parent.parent / "wordpress/wp-content/uploads/tts-samples"
+CONTAINER = "wordpress-web"
+
+
+def get_post_text(pid):
+ subprocess.run(["docker", "exec", CONTAINER, "php", "/tmp/fea_post_io.php", "get", str(pid)],
+ check=True, capture_output=True)
+ subprocess.run(["docker", "cp", f"{CONTAINER}:/tmp/fea_es.json", "/tmp/fea_es.json"], check=True)
+ d = json.load(open("/tmp/fea_es.json"))
+ raw = d["content"]
+ raw = re.sub(r"(?i)||", "\n", raw)
+ raw = re.sub(r"<[^>]+>", "", raw)
+ raw = re.sub(r"\[[^\]]+\]", "", raw)
+ raw = html.unescape(raw)
+ paras = [re.sub(r"\s+", " ", p).strip() for p in raw.split("\n")]
+ return d["title"], [p for p in paras if len(p) > 1]
+
+
+def main():
+ pid = int(sys.argv[1])
+ voice = sys.argv[2] if len(sys.argv) > 2 else "es-ES-XimenaNeural"
+ name = sys.argv[3] if len(sys.argv) > 3 else f"carta-edge-{pid}"
+ title, paras = get_post_text(pid)
+ text = "\n\n".join(paras)
+ txt_path = "/tmp/carta_text.txt"
+ open(txt_path, "w").write(text)
+ print(f"Post #{pid}: «{title}» ({len(text)} car) → {voice}")
+ OUT.mkdir(parents=True, exist_ok=True)
+ mp3 = OUT / f"{name}.mp3"
+ subprocess.run([EDGE, "--voice", voice, "--file", txt_path,
+ "--write-media", str(mp3)], check=True)
+ print(f"OK -> {mp3}")
+
+
+if __name__ == "__main__":
+ main()
diff --git a/scripts/tts_eval.py b/scripts/tts_eval.py
new file mode 100644
index 0000000..8feea01
--- /dev/null
+++ b/scripts/tts_eval.py
@@ -0,0 +1,82 @@
+#!/usr/bin/env python3
+"""
+tts_eval.py — Genera la MISMA frase de feadulta con varias voces/modelos TTS para
+compararlas (evaluación de voz, issue #76). Incluye:
+ - edge-tts Ximena (referencia, gratis, ya la usamos) — siempre.
+ - Modelos premium vía Hugging Face Inference Providers (consume crédito HF) — opcional.
+
+Objetivo: ELEGIR voz. Para producción en masa NO se usa HF (sale caro); el modelo
+abierto ganador se corre en LOCAL (RTX 5060 Ti) gratis. Ver análisis en #76.
+
+Uso:
+ # Solo la referencia local (gratis):
+ python3 scripts/tts_eval.py
+ # Con modelos HF (necesita token; gasta unos céntimos del crédito):
+ HF_TOKEN=hf_xxx python3 scripts/tts_eval.py --hf
+
+Salida: ./tts-eval/.mp3 (escúchalos y elige).
+"""
+from __future__ import annotations
+import argparse, os, subprocess, sys
+from pathlib import Path
+
+SAMPLE = (
+ "Bienvenido a Fe Adulta. La humanidad abriga una esperanza: verse liberada de la "
+ "esclavitud y alcanzar la libertad de los hijos de Dios. Una fe adulta es una fe "
+ "personal, valiente, sin miedos infantiles. Detente un instante y respira."
+)
+OUT = Path(__file__).resolve().parent.parent / "tts-eval"
+EDGE = os.path.expanduser("~/.hermes/hermes-agent/venv/bin/edge-tts")
+
+# Candidatos vía HF Inference Providers (provider, model). Verifica disponibilidad en la
+# pestaña "Inference Providers" de cada modelo en huggingface.co — el routing cambia.
+HF_CANDIDATES = [
+ ("fal-ai", "fal-ai/f5-tts"),
+ ("fal-ai", "fal-ai/chatterbox/text-to-speech"),
+ ("hf-inference", "myshell-ai/MeloTTS-Spanish"),
+]
+
+
+def edge_samples():
+ OUT.mkdir(exist_ok=True)
+ for voz in ("es-ES-XimenaNeural", "es-ES-ElviraNeural", "es-MX-JorgeNeural"):
+ dst = OUT / f"edge-{voz}.mp3"
+ print(f"edge-tts {voz} ...", flush=True)
+ subprocess.run([EDGE, "--voice", voz, "--text", SAMPLE, "--write-media", str(dst)],
+ capture_output=True)
+ print(f" -> {OUT}")
+
+
+def hf_samples():
+ try:
+ from huggingface_hub import InferenceClient
+ except ImportError:
+ sys.exit("Falta huggingface_hub: pip install huggingface_hub")
+ token = os.environ.get("HF_TOKEN")
+ if not token:
+ sys.exit("Define HF_TOKEN para usar --hf")
+ OUT.mkdir(exist_ok=True)
+ for provider, model in HF_CANDIDATES:
+ name = model.replace("/", "_")
+ try:
+ client = InferenceClient(provider=provider, api_key=token)
+ audio = client.text_to_speech(SAMPLE, model=model)
+ dst = OUT / f"hf-{name}.mp3"
+ dst.write_bytes(audio)
+ print(f"OK {provider}:{model} -> {dst.name}")
+ except Exception as exc: # noqa: BLE001
+ print(f"FALLO {provider}:{model} -> {exc}")
+
+
+def main():
+ ap = argparse.ArgumentParser()
+ ap.add_argument("--hf", action="store_true", help="También generar con modelos HF (gasta crédito).")
+ args = ap.parse_args()
+ edge_samples()
+ if args.hf:
+ hf_samples()
+ print("\nEscucha los .mp3 en", OUT, "y elige. Para producción: correr el modelo abierto ganador en local.")
+
+
+if __name__ == "__main__":
+ raise SystemExit(main())
diff --git a/scripts/tts_kokoro.py b/scripts/tts_kokoro.py
new file mode 100644
index 0000000..9242f3b
--- /dev/null
+++ b/scripts/tts_kokoro.py
@@ -0,0 +1,41 @@
+#!/usr/bin/env python3
+"""Genera la muestra de feadulta con Kokoro (TTS local, gratis). Issue #76.
+
+Voces español: ef_dora (fem), em_alex / em_santa (masc). lang_code 'e' = español.
+Salida en uploads/tts-samples/ como kokoro-.wav (+ mp3 si hay ffmpeg).
+"""
+import subprocess
+import sys
+from pathlib import Path
+
+import numpy as np
+import soundfile as sf
+from kokoro import KPipeline
+
+SAMPLE = (
+ "Bienvenido a Fe Adulta. La humanidad abriga una esperanza: verse liberada de la "
+ "esclavitud y alcanzar la libertad de los hijos de Dios. Una fe adulta es una fe "
+ "personal, valiente, sin miedos infantiles. Detente un instante y respira."
+)
+OUT = Path(__file__).resolve().parent.parent / "wordpress/wp-content/uploads/tts-samples"
+SR = 24000
+VOICES = sys.argv[1:] or ["ef_dora", "em_alex"]
+
+
+def main():
+ OUT.mkdir(parents=True, exist_ok=True)
+ pipe = KPipeline(lang_code="e") # español
+ for voice in VOICES:
+ chunks = [audio for _, _, audio in pipe(SAMPLE, voice=voice)]
+ audio = np.concatenate(chunks) if len(chunks) > 1 else chunks[0]
+ wav = OUT / f"kokoro-{voice}.wav"
+ sf.write(wav, audio, SR)
+ mp3 = OUT / f"kokoro-{voice}.mp3"
+ subprocess.run(["ffmpeg", "-y", "-i", str(wav), "-b:a", "96k", str(mp3)],
+ capture_output=True)
+ dur = len(audio) / SR
+ print(f"OK {voice}: {dur:.1f}s -> {mp3.name}")
+
+
+if __name__ == "__main__":
+ main()
diff --git a/scripts/tts_produce.py b/scripts/tts_produce.py
new file mode 100644
index 0000000..7d3c201
--- /dev/null
+++ b/scripts/tts_produce.py
@@ -0,0 +1,118 @@
+#!/usr/bin/env python3
+"""Orquestador nocturno: locuta cartas ES del gap con MiniMax (voz Nico), una a
+una, repartido en el tiempo. Reanudable (meta fea_audio_done) y con freno ante
+la cuota (para tras N fallos seguidos). NO toca el front; solo genera el mp3 y
+asocia la URL al post (meta fea_audio_url).
+
+Lanzar: nohup ~/tts-local/xtts-venv/bin/python scripts/tts_produce.py > /tmp/feadulta-tts-prod.out 2>&1 &
+Log: /tmp/feadulta-tts-prod.log
+"""
+import os
+import shutil
+import subprocess
+import sys
+import time
+from pathlib import Path
+
+sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
+import minimax_tts as mm # get_post_text, add_pauses, t2a, OUT
+import translate_post as tp # carta_article_ids
+
+VOICE = "NicoFeadulta2026"
+MODEL = "speech-2.8-hd"
+CONTAINER = "wordpress-web"
+PROD = Path(__file__).resolve().parent.parent / "wordpress/wp-content/uploads/tts"
+LOG = Path("/tmp/feadulta-tts-prod.log")
+INTERVAL = 180 # s entre cartas exitosas (reparte el ritmo)
+BACKOFF = 1800 # s de espera ante fallo de cuota antes de reintentar
+MAX_CONSEC_FAIL = 3 # fallos seguidos → parar (cuota probablemente agotada)
+MIN_CHARS = 200 # por debajo, se considera sin contenido locutable
+
+# Cola de cartas a locutar. Override por entorno (FEA_TTS_CARTAS) para priorizar
+# la carta nueva de la semana; si no, cae al orden del gap histórico.
+_DEFAULT_CARTAS = "45018 44997 44975 44230 44229 44228 44090 44089 44088 44087 44086 44085 44084 44083 42590"
+CARTAS = os.environ.get("FEA_TTS_CARTAS", _DEFAULT_CARTAS).replace(",", " ").split()
+
+
+def log(msg):
+ line = f"[{time.strftime('%Y-%m-%d %H:%M:%S')}] {msg}"
+ print(line, flush=True)
+ with LOG.open("a") as f:
+ f.write(line + "\n")
+
+
+def php(*args):
+ return subprocess.run(["docker", "exec", CONTAINER, "php", "/tmp/fea_post_io.php", *args],
+ capture_output=True, text=True)
+
+
+def meta(pid, key):
+ return php("getmeta", str(pid), key).stdout.strip()
+
+
+def build_queue():
+ # Cola literal de IDs (ya filtrada/ordenada) para priorizar la carta nueva.
+ ids_override = os.environ.get("FEA_TTS_IDS", "").replace(",", " ").split()
+ if ids_override:
+ return [int(x) for x in ids_override if x.strip().isdigit()]
+ q = []
+ for c in CARTAS:
+ cid = int(c)
+ for pid in tp.carta_article_ids(cid):
+ if pid not in q:
+ q.append(pid)
+ return q
+
+
+def main():
+ PROD.mkdir(parents=True, exist_ok=True)
+ subprocess.run(["docker", "cp", "scripts/fea_post_io.php", f"{CONTAINER}:/tmp/fea_post_io.php"],
+ capture_output=True)
+ queue = build_queue()
+ log(f"=== INICIO orquestador TTS. Cola: {len(queue)} posts ES del gap ===")
+
+ i = consec = ok = 0
+ while i < len(queue):
+ pid = queue[i]
+ if meta(pid, "fea_audio_done") == "1" or meta(pid, "fea_audio_skip") == "1":
+ i += 1
+ continue
+ try:
+ title, text = mm.get_post_text(pid)
+ except Exception as e: # noqa: BLE001
+ log(f"#{pid}: error leyendo ({e}); skip")
+ php("setflag", str(pid), "fea_audio_skip", "1")
+ i += 1
+ continue
+ if len(text) < MIN_CHARS:
+ log(f"#{pid}: sin contenido ({len(text)} car); skip")
+ php("setflag", str(pid), "fea_audio_skip", "1")
+ i += 1
+ continue
+
+ rc = mm.t2a(mm.add_pauses(text), VOICE, MODEL, f"prod-{pid}")
+ if rc == 0:
+ src = mm.OUT / f"prod-{pid}.mp3"
+ dst = PROD / f"{pid}.mp3"
+ shutil.move(str(src), str(dst))
+ php("setaudio", str(pid), f"/wp-content/uploads/tts/{pid}.mp3")
+ ok += 1
+ consec = 0
+ log(f"#{pid} OK «{title[:45]}» → tts/{pid}.mp3 (total {ok})")
+ i += 1
+ time.sleep(INTERVAL)
+ else:
+ consec += 1
+ log(f"#{pid} FALLO rc={rc} (fallo seguido {consec}/{MAX_CONSEC_FAIL})")
+ php("setflag", str(pid), "fea_audio_error", str(rc))
+ if consec >= MAX_CONSEC_FAIL:
+ log("Demasiados fallos seguidos → cuota agotada probablemente. PARO. "
+ "Reanudable: relanzar el script más tarde (salta lo ya hecho).")
+ break
+ time.sleep(BACKOFF) # reintenta el mismo post tras esperar
+
+ log(f"=== FIN tanda. {ok} audios generados esta ejecución. ===")
+
+
+if __name__ == "__main__":
+ main()
diff --git a/scripts/tts_xtts.py b/scripts/tts_xtts.py
new file mode 100644
index 0000000..34ab09f
--- /dev/null
+++ b/scripts/tts_xtts.py
@@ -0,0 +1,72 @@
+#!/usr/bin/env python3
+"""Clona una voz con XTTS-v2 (local) y locuta la muestra de feadulta. Issue #76.
+
+Uso:
+ tts_xtts.py [nombre_salida]
+La muestra: 6-20s de voz limpia en español. Salida en uploads/tts-samples/.
+
+NOTA: XTTS-v2 tiene licencia no comercial (CPML). En CPU tarda ~1-2 min por
+muestra; con GPU sería casi instantáneo.
+"""
+import os
+import subprocess
+import sys
+from pathlib import Path
+
+os.environ.setdefault("COQUI_TOS_AGREED", "1") # acepta licencia CPML no-interactivo
+
+import torch # noqa: E402
+from TTS.api import TTS # noqa: E402
+
+DEVICE = "cuda" if torch.cuda.is_available() and not os.environ.get("FEA_CPU") else "cpu"
+
+SAMPLE = (
+ "Bienvenido a Fe Adulta. La humanidad abriga una esperanza: verse liberada de la "
+ "esclavitud y alcanzar la libertad de los hijos de Dios. Una fe adulta es una fe "
+ "personal, valiente, sin miedos infantiles. Detente un instante y respira."
+)
+OUT = Path(__file__).resolve().parent.parent / "wordpress/wp-content/uploads/tts-samples"
+
+
+def main():
+ if len(sys.argv) < 2:
+ sys.exit("uso: tts_xtts.py [nombre_salida]")
+ spk = sys.argv[1]
+ name = sys.argv[2] if len(sys.argv) > 2 else "xtts-clon"
+ OUT.mkdir(parents=True, exist_ok=True)
+
+ print(f"Cargando XTTS-v2 en {DEVICE}…", flush=True)
+ tts = TTS("tts_models/multilingual/multi-dataset/xtts_v2").to(DEVICE)
+ raw = OUT / f"{name}.raw.wav"
+ print(f"Clonando voz de {spk} y locutando…", flush=True)
+ tts.tts_to_file(
+ text=SAMPLE, speaker_wav=spk, language="es", file_path=str(raw),
+ temperature=0.65, # menos aleatoriedad → más estable
+ length_penalty=1.0,
+ repetition_penalty=5.0, # reduce artefactos/balbuceos en español
+ top_k=50,
+ top_p=0.85,
+ enable_text_splitting=True, # parte por frases → mejor prosodia
+ )
+ # Comfort noise: ruido marrón suave y constante que rellena los silencios de
+ # comas/puntos para que no contrasten con el suelo de ruido del habla clonada.
+ wav = OUT / f"{name}.wav"
+ if os.environ.get("FEA_NO_COMFORT"):
+ subprocess.run(["ffmpeg", "-y", "-i", str(raw), str(wav)], capture_output=True)
+ else:
+ subprocess.run([
+ "ffmpeg", "-y", "-i", str(raw), "-filter_complex",
+ "anoisesrc=color=brown:amplitude=0.004:sample_rate=24000[n];"
+ "[n]highpass=f=120,lowpass=f=3800[nf];"
+ "[0:a][nf]amix=inputs=2:duration=first:dropout_transition=0:normalize=0[a]",
+ "-map", "[a]", "-ar", "24000", str(wav),
+ ], capture_output=True)
+ raw.unlink(missing_ok=True)
+ mp3 = OUT / f"{name}.mp3"
+ subprocess.run(["ffmpeg", "-y", "-i", str(wav), "-b:a", "96k", str(mp3)],
+ capture_output=True)
+ print(f"OK -> {mp3}")
+
+
+if __name__ == "__main__":
+ main()
diff --git a/scripts/unpublish_date_slug_posts.php b/scripts/unpublish_date_slug_posts.php
new file mode 100644
index 0000000..d13d5b7
--- /dev/null
+++ b/scripts/unpublish_date_slug_posts.php
@@ -0,0 +1,153 @@
+posts;
+ $backup_table = $wpdb->prefix . 'fea_date_slug_posts_backup';
+
+ $count = (int)$wpdb->get_var("SELECT COUNT(*) FROM $posts_table WHERE $where");
+ echo "Matching published posts: $count\n";
+
+ $sample = $wpdb->get_results("
+ SELECT ID, post_date, post_title, post_name
+ FROM $posts_table
+ WHERE $where
+ ORDER BY post_date DESC
+ LIMIT 20
+ ", ARRAY_A);
+
+ foreach ($sample as $row) {
+ echo sprintf(
+ " #%d %s %s (%s)\n",
+ $row['ID'],
+ $row['post_date'],
+ $row['post_title'],
+ $row['post_name']
+ );
+ }
+
+ if ($dry_run) {
+ echo "\nNo changes made. Re-run with APPLY=1 to set these posts to draft.\n";
+ return;
+ }
+
+ $wpdb->query("
+ CREATE TABLE IF NOT EXISTS $backup_table (
+ post_id BIGINT UNSIGNED NOT NULL PRIMARY KEY,
+ old_status VARCHAR(20) NOT NULL,
+ old_modified DATETIME NOT NULL,
+ backed_up_at DATETIME NOT NULL
+ ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4
+ ");
+
+ $backed_up = $wpdb->query("
+ INSERT IGNORE INTO $backup_table (post_id, old_status, old_modified, backed_up_at)
+ SELECT ID, post_status, post_modified, NOW()
+ FROM $posts_table
+ WHERE $where
+ ");
+
+ $updated = $wpdb->query("
+ UPDATE $posts_table
+ SET post_status = 'draft',
+ post_modified = NOW(),
+ post_modified_gmt = UTC_TIMESTAMP()
+ WHERE $where
+ ");
+
+ echo "\nBacked up rows in $backup_table: $backed_up\n";
+ echo "Posts set to draft: $updated\n";
+ return;
+}
+
+$db_host = getenv('WORDPRESS_DB_HOST') ?: 'wordpress-db';
+$db_name = getenv('WORDPRESS_DB_NAME') ?: 'wordpress_db';
+$db_user = getenv('WORDPRESS_DB_USER') ?: 'wordpress_user';
+$db_pass = getenv('WORDPRESS_DB_PASSWORD') ?: 'wordpress_pass';
+
+$pdo = new PDO("mysql:host=$db_host;dbname=$db_name;charset=utf8mb4", $db_user, $db_pass, [
+ PDO::ATTR_ERRMODE => PDO::ERRMODE_EXCEPTION,
+]);
+
+$count = (int)$pdo->query("SELECT COUNT(*) FROM wp_posts WHERE $where")->fetchColumn();
+echo "Matching published posts: $count\n";
+
+$sample = $pdo->query("
+ SELECT ID, post_date, post_title, post_name
+ FROM wp_posts
+ WHERE $where
+ ORDER BY post_date DESC
+ LIMIT 20
+")->fetchAll(PDO::FETCH_ASSOC);
+
+foreach ($sample as $row) {
+ echo sprintf(
+ " #%d %s %s (%s)\n",
+ $row['ID'],
+ $row['post_date'],
+ $row['post_title'],
+ $row['post_name']
+ );
+}
+
+if ($dry_run) {
+ echo "\nNo changes made. Re-run with --apply to set these posts to draft.\n";
+ exit(0);
+}
+
+$pdo->exec("
+ CREATE TABLE IF NOT EXISTS $backup_table (
+ post_id BIGINT UNSIGNED NOT NULL PRIMARY KEY,
+ old_status VARCHAR(20) NOT NULL,
+ old_modified DATETIME NOT NULL,
+ backed_up_at DATETIME NOT NULL
+ ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4
+");
+
+$pdo->beginTransaction();
+
+$backed_up = $pdo->exec("
+ INSERT IGNORE INTO $backup_table (post_id, old_status, old_modified, backed_up_at)
+ SELECT ID, post_status, post_modified, NOW()
+ FROM wp_posts
+ WHERE $where
+");
+
+$updated = $pdo->exec("
+ UPDATE wp_posts
+ SET post_status = 'draft',
+ post_modified = NOW(),
+ post_modified_gmt = UTC_TIMESTAMP()
+ WHERE $where
+");
+
+$pdo->commit();
+
+echo "\nBacked up rows in $backup_table: $backed_up\n";
+echo "Posts set to draft: $updated\n";