AppInitDev
CÓDIGO FUENTE PÚBLICO

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()