tools/generar_catalogo.py
Archivo real del paquete para implementar la función. Descárgalo del ZIP para editarlo; no contiene claves privadas.
#!/usr/bin/env python3
"""Genera catálogo IA completo con sitemap, archivos HTML, manifiesto y URLs adicionales.
Sin conexión externa. No edita sitemap.xml, index.html, app.html, .htaccess ni pages/.
Los reportes de diagnóstico quedan PRIVADOS en AppInitDev_IA_MCP/reportes/.
"""
import argparse
import csv
import json
import re
import shutil
import sys
import xml.etree.ElementTree as ET
from collections import Counter, defaultdict
from datetime import datetime, timezone
from html import unescape, escape
from html.parser import HTMLParser
from pathlib import Path
from urllib.parse import urljoin, urlsplit, urlunsplit
BASE = 'https://appinitdev.com'
SLUG = re.compile(r'^[a-z0-9][a-z0-9-]{0,63}$')
def normalize_text(value, limit=250):
text=unescape(re.sub(r'<[^>]*>', ' ', str(value or '')))
return re.sub(r'\s+', ' ', text).strip()[:limit]
def build_apps(source):
result=[]; seen=set()
for item in source:
if not isinstance(item,dict):continue
slug=str(item.get('slug') or '').lower().strip()
pkg=str(item.get('appId') or '').strip()
if not SLUG.fullmatch(slug) or not re.fullmatch(r'[A-Za-z0-9_]+(?:\.[A-Za-z0-9_]+)+',pkg) or pkg in seen:continue
seen.add(pkg)
result.append({
'id':pkg, 'slug':slug, 'nombre':normalize_text(item.get('title'),140),
'resumen':normalize_text(item.get('summary') or item.get('description'),360),
'categoria':normalize_text(item.get('genre'),90),
'url':f'https://{slug}.appinitdev.com/',
'play_store':f'https://play.google.com/store/apps/details?id={pkg}',
'icono':BASE+str(item.get('icon')) if str(item.get('icon','')).startswith('/') else None,
'tipo':'gratuita' if str(item.get('free')).lower() in ('true','1') else ('de_pago' if str(item.get('free')).lower() in ('false','0') else 'no_verificado'),
'version':normalize_text(item.get('version'),80) or None,
'ultima_actualizacion_publicada':None if str(item.get('lastUpdatedOn') or '') in ('None','') else str(item.get('lastUpdatedOn')),
'fuente':'catalogo_oficial_appinitdev',
})
return sorted(result,key=lambda a:a['nombre'].casefold())
def build_static_catalog(out, payloads):
"""Exporta páginas HTML enlazadas para rastreadores que no ejecutan JavaScript."""
base = out / 'ia' / 'catalogo'
sections = (
('apps', 'Aplicaciones Android', 'apps.json', 'nombre', 'resumen'),
('conocimiento', 'Guías e investigaciones', 'conocimiento.json', 'titulo', 'descripcion'),
('secciones', 'Secciones detectadas', 'secciones.json', 'titulo', 'categoria'),
)
css = ("body{font-family:system-ui,sans-serif;max-width:1000px;margin:auto;padding:24px 18px;"
"background:#f6f8fd;color:#15284b;line-height:1.6}a{color:#214eca}"
"header,footer{padding:15px 0}nav{display:flex;flex-wrap:wrap;gap:12px}"
".panel{background:white;border:1px solid #dce6f4;border-radius:12px;"
"padding:15px;margin:10px 0}h1{line-height:1.2}small{color:#4f657e}")
def shell(title, url, description, content):
title = escape(title, quote=True)
description = escape(description, quote=True)
url = escape(url, quote=True)
return (
'<!doctype html><html lang="es-MX"><head><meta charset="utf-8">'
'<meta name="viewport" content="width=device-width,initial-scale=1">'
f'<title>{title} | AppInitDev</title>'
f'<meta name="description" content="{description}">'
f'<link rel="canonical" href="{url}"><style>{css}</style></head><body>'
'<header><nav><a href="/">Inicio</a><a href="/ia/">Centro IA</a>'
'<a href="/ia/catalogo/">Catálogo HTML</a></nav></header>'
f'<main><h1>{title}</h1><p>{description}</p>{content}</main>'
'<footer>Fuente editorial: AppInitDev. Consulta las páginas originales para información completa.</footer>'
'</body></html>'
)
nav = ''.join(
f'<li><a href="/ia/catalogo/{slug}/">{escape(label)}</a>: {payloads[file]["total"]} registros</li>'
for slug, label, file, _, _ in sections
)
index = base / 'index.html'
index.parent.mkdir(parents=True, exist_ok=True)
index.write_text(shell('Catálogo público de AppInitDev', BASE + '/ia/catalogo/',
'Índice HTML de aplicaciones, guías y secciones de AppInitDev.',
f'<ul>{nav}</ul><p>Catálogos abiertos en <a href="/datos/apps.json">JSON</a>.</p>'),
encoding='utf-8')
per_page = 100
for slug, label, filename, title_key, description_key in sections:
records = payloads[filename]['items']
pages = max(1, (len(records) + per_page - 1) // per_page)
for number in range(1, pages + 1):
relative = (f'/ia/catalogo/{slug}/' if number == 1
else f'/ia/catalogo/{slug}/pagina-{number}/')
chunks = []
for record in records[(number - 1) * per_page:number * per_page]:
title = escape(str(record.get(title_key) or 'Sin título'))
description = escape(str(record.get(description_key) or ''))
url = escape(record['url'], quote=True)
play = record.get('play_store')
play_html = ''
if isinstance(play, str) and play.startswith('https://play.google.com/store/apps/details?id='):
play_html = f' · <a href="{escape(play, quote=True)}">Google Play</a>'
chunks.append(f'<article class="panel"><h2><a href="{url}">{title}</a></h2>'
f'<p>{description}</p><small>Fuente: <a href="{url}">{url}</a>{play_html}</small></article>')
body = ''.join(chunks) if chunks else '<p>Aún no hay registros locales para esta sección.</p>'
if pages > 1:
links = []
for idx in range(1, pages + 1):
route = (f'/ia/catalogo/{slug}/' if idx == 1
else f'/ia/catalogo/{slug}/pagina-{idx}/')
links.append(f'<a href="{route}">{idx}</a>')
body += '<nav aria-label="Paginación">' + ''.join(links) + '</nav>'
title = label if number == 1 else f'{label}, página {number}'
dest = base / slug / ('index.html' if number == 1 else f'pagina-{number}/index.html')
dest.parent.mkdir(parents=True, exist_ok=True)
dest.write_text(shell(title, BASE + relative, f'Índice público de {label.lower()} de AppInitDev.', body),
encoding='utf-8')
return base
IGNORAR_DIRS = {'.git', '.github', '.idea', '.venv', 'venv', 'node_modules', 'backups',
'reportes', 'datos', 'ia', 'assets', 'icons', 'img', 'images', 'css', 'js',
'fonts', 'font', 'dist', 'build', '__pycache__', '_backup'}
IGNORAR_ARCHIVOS = {'error.html', '404.html', '500.html'}
RUTAS_REVISAR = ('/AppInitDev_SEO_GLOBAL/', '/yandex_', '/.git/', '/.env', '/backups/', '/_backup/', '/admin/')
SECCIONES_HERRAMIENTAS = {'suite','herramientas','demos','labs','laboratorio-web','digital-lab', 'influenser'}
SECCIONES_APPS = {'apps','directorios'}
SECCIONES_NO_DOCS = {'ia'}
SECCIONES_ES = {
'academy':'Academy', 'suite':'AppInitDev Suite', 'guias':'Guías',
'tutoriales':'Tutoriales', 'herramientas':'Herramientas web',
'soluciones':'Soluciones', 'investigaciones':'Investigaciones',
'laboratorio-web':'Laboratorio web', 'labs':'Laboratorios',
'digital-lab':'Digital Lab', 'influenser':'Influenser',
'apps':'Fichas de aplicaciones', 'directorios':'Directorios',
'prompts':'Prompts', 'recursos':'Recursos', 'crecimiento':'Crecimiento',
'crecimiento-apps':'Crecimiento de aplicaciones', 'demos':'Demostraciones',
'descubre':'Descubre', 'tendencias':'Tendencias', 'rutas':'Rutas',
'mejoras':'Mejoras', 'profundiza':'Profundiza', 'proyectos':'Proyectos',
'biblioteca-ampliada':'Biblioteca ampliada', 'screen':'Screen'
}
def canonical_url(value, root_url=BASE+'/', alias_slashes=None):
"""Normaliza host/HTML; no inventa que una ruta exista ni su canónica."""
if not isinstance(value, str): return None
value = unescape(value.strip())
if not value or value.startswith(('#', 'javascript:', 'mailto:', 'tel:', 'data:')):return None
try:
u=urlsplit(urljoin(root_url, value))
host=(u.hostname or '').lower()
if u.scheme not in ('https','http') or u.username or u.password or u.port not in (None, 80, 443):return None
if host == 'www.appinitdev.com':host='appinitdev.com'
if host!='appinitdev.com' and not host.endswith('.appinitdev.com'):return None
path=re.sub('/{2,}', '/', u.path or '/')
if path.endswith('/index.html') or path=='/index.html':path=path[:-10] or '/'
elif path=='/index':path='/'
elif path.endswith('.html'):path=path[:-5]
if path != '/' and alias_slashes and path.rstrip('/')+'/' in alias_slashes:
path=path.rstrip('/')+'/'
return f'https://{host}{path}'
except (ValueError,TypeError):return None
def risky(url):
return any(fragment.lower() in urlsplit(url).path.lower() for fragment in RUTAS_REVISAR)
def route_type(url):
prefix = urlsplit(url).path.strip('/').split('/',1)[0]
if prefix in SECCIONES_HERRAMIENTAS:return 'herramienta'
if prefix in SECCIONES_APPS:return 'ficha_app'
if not prefix:return 'inicio'
return 'articulo'
def route_section(url):
return urlsplit(url).path.strip('/').split('/',1)[0] or 'inicio'
def route_title(url):
path=urlsplit(url).path.strip('/')
if not path:return 'Inicio de AppInitDev'
name=path.split('/')[-1] or path.split('/')[-2]
if name.lower() in {'index'}:name=path.split('/')[-2] if '/' in path else 'inicio'
return name.replace('-', ' ').replace('_',' ').strip().capitalize()[:160]
class PageParser(HTMLParser):
def __init__(self):
super().__init__(convert_charrefs=True)
self.title_parts=[];self.h1_parts=[];self.main_parts=[];self.description='';self.canonical=None
self.noindex=False;self.updated=None;self.anchors=[]
self._title=0;self._h1=0;self._main=0;self._skip=0
def handle_starttag(self,tag,attrs):
attrs=dict(attrs)
if tag=='title':self._title+=1
if tag=='h1' and not self.h1_parts:self._h1+=1
if tag in ('main','article'):self._main+=1
if tag in ('script','style','template','svg'):self._skip+=1
if tag=='meta':
name=attrs.get('name','').lower();prop=attrs.get('property','').lower()
if name=='description':self.description=attrs.get('content','')
if name in ('robots','googlebot') and 'noindex' in attrs.get('content','').lower():self.noindex=True
if prop=='article:modified_time':self.updated=attrs.get('content','')
if tag=='link' and 'canonical' in str(attrs.get('rel','')).lower().split():self.canonical=attrs.get('href')
if tag=='a' and attrs.get('href'):
self.anchors.append((attrs.get('href'), ''))
def handle_endtag(self,tag):
if tag=='title':self._title=max(0,self._title-1)
if tag=='h1':self._h1=max(0,self._h1-1)
if tag in ('main','article'):self._main=max(0,self._main-1)
if tag in ('script','style','template','svg'):self._skip=max(0,self._skip-1)
def handle_data(self,data):
if self._skip:return
if self._title:self.title_parts.append(data)
if self._h1:self.h1_parts.append(data)
if self._main and len(self.main_parts)<180:self.main_parts.append(data)
@property
def title(self):return normalize_text(' '.join(self.title_parts),160)
@property
def h1(self):return normalize_text(' '.join(self.h1_parts),160)
@property
def extract(self):return normalize_text(' '.join(self.main_parts),600)
def load_sitemap(root):
entries={};warnings=[]
file=root/'sitemap.xml'
if not file.is_file():return entries,['No se encontró sitemap.xml en la raíz; se utilizarán HTML locales.']
try:xml=ET.parse(file).getroot()
except ET.ParseError as e:return entries,[f'Error XML en sitemap.xml: {e}']
for e in xml.iter():
if e.tag.rsplit('}',1)[-1]!='url':continue
loc=next((x.text for x in e if x.tag.rsplit('}',1)[-1]=='loc'),None)
lastmod=next((x.text for x in e if x.tag.rsplit('}',1)[-1]=='lastmod'),None)
url=canonical_url(loc)
if url is None:
warnings.append(f'URL fuera de AppInitDev o inválida en sitemap: {loc!r}')
continue
if url in entries:warnings.append(f'URL repetida tras normalización: {url}')
entries[url]={'url':url,'fecha_sitemap':lastmod,'url_original':loc}
return entries,warnings
def read_manifest(root):
f=root/'MANIFIESTO.json';mapping={};warnings=[]
if not f.is_file():return mapping,warnings
try:rows=json.loads(f.read_text(encoding='utf-8-sig'))
except (ValueError,OSError) as e:return mapping,[f'No se pudo abrir MANIFIESTO.json: {e}']
if not isinstance(rows,list):return {},['MANIFIESTO.json no es una lista.']
for row in rows:
if not isinstance(row,dict):continue
url=canonical_url(row.get('url') or '')
if not url:continue
mapping[url]={'titulo':normalize_text(row.get('title'),160),
'seccion':row.get('category','tutoriales'),'descripcion':'',
'fuente':'MANIFIESTO.json'}
return mapping,warnings
def local_candidates(root, apps_slugs, alias_slashes, max_html=50000):
pages={};anchors=set();stats=Counter();warnings=[];noindex_urls=set()
for folder, dirs, files in __import__('os').walk(root):
current=Path(folder)
dirs[:]=[d for d in dirs if (d not in IGNORAR_DIRS and not d.startswith('.') and
not d.startswith('AppInitDev_IA_MCP'))]
for name in files:
if name in IGNORAR_ARCHIVOS or not name.lower().endswith(('.html','.htm')):continue
file=current/name;relative=file.relative_to(root).as_posix()
stats['html_encontrados']+=1
if stats['html_encontrados']>max_html:
warnings.append(f'Máximo de {max_html} HTML alcanzado: hay páginas que no se inspeccionaron.')
return pages,anchors,stats,warnings,noindex_urls
try:
if file.stat().st_size>3_000_000:stats['html_grandes_omitidos']+=1;continue
html=file.read_text(encoding='utf-8-sig',errors='replace')[:1_400_000]
parser=PageParser();parser.feed(html)
except (OSError,ValueError) as e:
warnings.append(f'No se pudo leer {relative}: {str(e)[:100]}');continue
parts=Path(relative).parts
if parts[0]=='pages':
if len(parts)>2 and parts[1] in apps_slugs:
# La ficha de la app ya está en apps.json.
stats['html_app_pages']+=1
continue
stats['pages_no_asociadas']+=1
continue
if relative=='index.html':fallback=BASE+'/'
elif name.lower()=='index.html':fallback=BASE+'/'+file.parent.relative_to(root).as_posix().strip('/')+'/'
else:fallback=BASE+'/'+relative.rsplit('.',1)[0]
if parser.canonical:
url=canonical_url(parser.canonical, fallback, alias_slashes)
if url is None:
stats['canonicas_fuera_del_dominio']+=1
continue
else:url=canonical_url(fallback, alias_slashes=alias_slashes)
if not url or risky(url):
stats['rutas_privadas_descartadas']+=1;continue
if parser.noindex:
stats['noindex']+=1;noindex_urls.add(url);continue
if not parser.title and not parser.h1 and not parser.description:continue
if url not in pages or len(parser.extract)>len(pages[url]['contenido_extracto']):
pages[url]={
'titulo':parser.h1 or parser.title or route_title(url),
'descripcion':normalize_text(parser.description,350),
'contenido_extracto':parser.extract,
'fecha_actualizacion':parser.updated,
'fuente':'archivo_html_local','archivo_origen':relative,
'metadatos_reales':bool(parser.h1 or parser.title)
}
for href,_ in parser.anchors:
found=canonical_url(href,url,alias_slashes)
if found and not risky(found):anchors.add(found)
return pages,anchors,stats,warnings,noindex_urls
def parse_hrefs_main(root, alias_slashes):
"""Extrae hrefs aunque se desconozca el contenido de la página destino."""
class Anchors(HTMLParser):
def __init__(self):super().__init__();self.urls=set()
def handle_starttag(self,t,attrs):
if t!='a':return
href=dict(attrs).get('href')
u=canonical_url(href,BASE+'/',alias_slashes)
if u and not risky(u):self.urls.add(u)
p=Anchors();f=root/'index.html'
if f.exists():p.feed(f.read_text(encoding='utf-8-sig',errors='replace'))
return p.urls
def read_extra_urls(root, alias_slashes):
f=root/'URLs_ADICIONALES.txt';out=set();warnings=[]
if not f.is_file():return out,warnings
for number,line in enumerate(f.read_text(encoding='utf-8-sig').splitlines(),1):
url=line.strip()
if not url or url.startswith('#'):continue
value=canonical_url(url,alias_slashes=alias_slashes)
if not value or risky(value):warnings.append(f'URL_ADICIONAL inválida o privada, línea {number}: {url}')
else:out.add(value)
return out,warnings
def read_llms_links(root, alias_slashes):
links=set()
for file in ('llms.txt','llms-full.txt'):
f=root/file
if not f.exists():continue
content=f.read_text(encoding='utf-8-sig',errors='replace')
for match in re.findall(r'https?://[^\s\)\]<>\"\']+',content):
url=canonical_url(match.rstrip('.,'),alias_slashes=alias_slashes)
if url and not risky(url):links.add(url)
return links
def assemble_knowledge(sitemap,manifest,local_pages,extras,apps,report,noindex_urls):
seen_hosts={a['url'] for a in apps};docs=[];excluded=[]
candidates=set(sitemap)|set(local_pages)|set(extras)
for url in sorted(candidates):
if url in seen_hosts:continue
if url in noindex_urls:
excluded.append({'url':url,'motivo':'Marcada noindex en HTML local'})
continue
if risky(url):
excluded.append({'url':url,'motivo':'Ruta de verificación o posible ruta interna; revisar antes de indexar en IA'})
continue
if urlsplit(url).hostname!='appinitdev.com':
excluded.append({'url':url,'motivo':'Subdominio sin ficha reconocida en apps.json'})
continue
local=local_pages.get(url);man=manifest.get(url)
src=[]
if url in sitemap:src.append('sitemap.xml')
if man:src.append('MANIFIESTO.json')
if local:src.append('HTML_local')
if url in extras:src.append('URLs_ADICIONALES.txt')
if local: title=local['titulo']; desc=local['descripcion']
elif man: title=man['titulo'] or route_title(url);desc=man['descripcion']
else:title=route_title(url);desc=''
docs.append({
'titulo':title, 'descripcion':desc,
'url':url, 'tipo':route_type(url), 'seccion':route_section(url),
'fuente':'+'.join(src), 'fecha_actualizacion':local.get('fecha_actualizacion') if local else None,
'fecha_sitemap':sitemap.get(url,{}).get('fecha_sitemap'),
'contenido_extracto':local.get('contenido_extracto','') if local else '',
'titulo_obtenido_de':('HTML_local' if local else 'MANIFIESTO.json' if man else 'ruta_url'),
'estado_verificacion':('metadatos_html_locales' if local else 'declaracion_sitemap_o_url'),
})
report['rutas_excluidas_revision']=excluded
return docs
def sections_from_knowledge(docs, sitemap, local_pages, apps):
groups=defaultdict(list)
for d in docs:groups[d['seccion']].append(d)
sections=[]
for slug, rows in sorted(groups.items(),key=lambda x:(-len(x[1]),x[0])):
if slug=='inicio':continue
if len(rows)==1 and slug not in SECCIONES_ES:continue
root_url=BASE+'/'+slug+'/'
# Secciones sin landing conocida enlazan a un documento que sí está en el inventario.
section_url=root_url if (root_url in sitemap or root_url in local_pages) else rows[0]['url']
cat=('apps' if slug in SECCIONES_APPS else 'herramientas' if slug in SECCIONES_HERRAMIENTAS else 'articulos')
sections.append({'titulo':SECCIONES_ES.get(slug,slug.replace('-',' ').capitalize()),
'url':section_url,'categoria':cat,'fuente':'agrupacion_de_contenido',
'total_paginas':len(rows),'ruta_base':root_url})
# URL oficial de apps detectada en las fichas, NO inventar un directorio inexistente.
return sections
def json_write(path,value):
path.parent.mkdir(parents=True,exist_ok=True)
tmp=path.with_suffix(path.suffix+'.tmp')
tmp.write_text(json.dumps(value,ensure_ascii=False,indent=2)+'\n',encoding='utf-8')
tmp.replace(path)
def main():
parser=argparse.ArgumentParser(description=__doc__)
parser.add_argument('--root',default='.')
parser.add_argument('--out',default=None)
parser.add_argument('--mirror-mcp',default=None)
parser.add_argument('--max-html',type=int,default=50000)
opts=parser.parse_args()
root=Path(opts.root).resolve();out=Path(opts.out).resolve() if opts.out else root
source=root/'apps_full_data.json'
if not source.is_file():raise SystemExit('Falta apps_full_data.json actualizado en la raíz del proyecto.')
rows=json.loads(source.read_text(encoding='utf-8-sig'))
if isinstance(rows,dict):rows=rows.get('apps',[])
if not isinstance(rows,list):raise SystemExit('apps_full_data.json no es lista válida.')
apps=build_apps(rows)
if not apps:raise SystemExit('No se encontraron aplicaciones válidas.')
sitemap,warnings=load_sitemap(root)
slashed={urlsplit(x).path for x in sitemap if x.startswith(BASE+'/') and x.endswith('/')}
# La canónica del sitemap prevalece para rutas con y sin barra final.
canonicalized={}
for u,v in sitemap.items():
candidate=canonical_url(u,alias_slashes=slashed)
if candidate in canonicalized:
warnings.append('Variantes con/sin barra final en sitemap: '+u)
canonicalized[candidate]=v
sitemap=canonicalized
manifest,part_warnings=read_manifest(root);warnings.extend(part_warnings)
local,links,stats,part_warnings,noindex_urls=local_candidates(root,{a['slug'] for a in apps},slashed,opts.max_html)
warnings.extend(part_warnings)
links|=parse_hrefs_main(root,slashed)
extra,part_warnings=read_extra_urls(root,slashed);warnings.extend(part_warnings)
llms=read_llms_links(root,slashed)
report={'sitemap_total':len(sitemap),'subdominios_sitemap':len(set(urlsplit(u).hostname for u in sitemap if urlsplit(u).hostname!='appinitdev.com')),
'aplicaciones_validas':len(apps),'manifest_total':len(manifest),'archivos_html':dict(stats),
'avisos':warnings}
docs=assemble_knowledge(sitemap,manifest,local,extra,apps,report,noindex_urls)
sections=sections_from_knowledge(docs,sitemap,local,apps)
in_sitemap=set(sitemap)
all_links=links|llms
report['conocimiento_total']=len(docs)
report['secciones_total']=len(sections)
report['rutas_adicionales_confirmadas_en_archivos_locales']=sorted(set(local)-in_sitemap)
report['rutas_anadidas_manualmente']=sorted(extra-in_sitemap)
report['candidatas_en_enlaces_sin_sitemap_ni_html']=sorted(all_links-in_sitemap-set(local)-extra)
report['sin_metadatos_html_locales']=sum(d['titulo_obtenido_de']!='HTML_local' for d in docs)
report['origenes_documentos']=dict(Counter('HTML_local' if 'HTML_local' in d['fuente'] else 'MANIFIESTO.json' if 'MANIFIESTO.json' in d['fuente'] else 'sitemap_solo' if 'sitemap.xml' in d['fuente'] else 'URLs_ADICIONALES.txt' for d in docs))
report['cobertura_por_seccion']={k:len(v) for k,v in sorted(((k,[d for d in docs if d['seccion']==k]) for k in {d['seccion'] for d in docs}),key=lambda p:-len(p[1]))}
report['sin_sitemap_detalle']=[{'url':u,'origen':('HTML_local' if u in local else 'URLs_ADICIONALES.txt' if u in extra else 'enlace_no_verificado')} for u in sorted((set(local)|extra|all_links)-in_sitemap) if not risky(u)]
report['sitemap_sin_archivo_html_en_este_zip']=len(in_sitemap-set(local)-set(a['url'] for a in apps))
report['noindex_excluidas']=len(noindex_urls)
report['rutas_duplicadas_por_barras_sitemap']=sum('Variantes con/sin barra final' in w for w in warnings)
stamp=datetime.now(timezone.utc).isoformat(timespec='seconds')
metadata={'generado_el':stamp,'fuente_datos':'apps_full_data.json / sitemap.xml / MANIFIESTO.json / HTML local',
'nota':'Sitemap y enlaces son declaraciones, no prueba de disponibilidad HTTP. Fechas sitemap NO son verificación editorial.'}
payloads={
'apps.json':{'metadatos':metadata,'total':len(apps),'items':apps},
'conocimiento.json':{'metadatos':metadata,'total':len(docs),'items':docs},
'secciones.json':{'metadatos':metadata,'total':len(sections),'items':sections}}
for name,payload in payloads.items():json_write(out/'datos'/name,payload)
build_static_catalog(out,payloads)
if opts.mirror_mcp:
mirror=Path(opts.mirror_mcp);mirror.mkdir(parents=True,exist_ok=True)
for name in payloads:shutil.copy2(out/'datos'/name,mirror/name)
private=Path(__file__).resolve().parent.parent/'reportes';private.mkdir(exist_ok=True)
json_write(private/'diagnostico.json',report)
with (private/'enlaces_fuera_del_sitemap.csv').open('w',newline='',encoding='utf-8-sig') as f:
writer=csv.DictWriter(f,fieldnames=['url','origen']);writer.writeheader();writer.writerows(report['sin_sitemap_detalle'])
with (private/'distribucion_sitemap.csv').open('w',newline='',encoding='utf-8-sig') as f:
writer=csv.writer(f);writer.writerow(['seccion','total_paginas']);writer.writerows((k,v) for k,v in report['cobertura_por_seccion'].items())
print(f'Sitemap: {len(sitemap)} URLs | Apps: {len(apps)} | Conocimiento: {len(docs)} | Secciones: {len(sections)}')
print('Rutas locales adicionales:',len(report['rutas_adicionales_confirmadas_en_archivos_locales']))
print('Enlaces candidatos para verificar:',len(report['candidatas_en_enlaces_sin_sitemap_ni_html']))
print('Contenido sin metadatos HTML locales:',report['sin_metadatos_html_locales'])
print('Reporte privado:', private/'diagnostico.json')
print('Salida pública:',out/'datos', 'y',out/'ia/catalogo')
if __name__=='__main__':main()