AppInitDev
CÓDIGO FUENTE PÚBLICO

tools/extension_final.py

Archivo real del paquete para implementar la función. Descárgalo del ZIP para editarlo; no contiene claves privadas.

#!/usr/bin/env python3
"""Extensión FINAL: grafo verificado, idiomas, comparación offline Play, impacto y evaluación.
Solo datos públicos agregados en /datos; informes de detalle privados en /AppInitDev_IA_MCP/reportes.
Sin dependencias ni acceso a la red. No modifica /pages/, Play Console ni el index.
"""
from __future__ import annotations
import csv, json, re, unicodedata
from collections import Counter
from datetime import datetime, timezone
from pathlib import Path
from urllib.parse import urlsplit

MOD=Path(__file__).resolve().parent.parent
NOW=lambda:datetime.now(timezone.utc).isoformat(timespec='seconds')

def load(path,default=None):
    try:return json.loads(path.read_text(encoding='utf-8-sig'))
    except (FileNotFoundError,json.JSONDecodeError):return default

def save(path, obj):
    path.parent.mkdir(parents=True,exist_ok=True)
    tmp=path.with_name(path.name+'.tmp')
    tmp.write_text(json.dumps(obj,ensure_ascii=False,indent=2)+'\n',encoding='utf-8')
    tmp.replace(path)

def norm(v):
    s=unicodedata.normalize('NFKD',str(v or '').casefold())
    return ''.join(c for c in s if not unicodedata.combining(c))

def valid_app_url(url):
    u=urlsplit(str(url or ''))
    return u.scheme=='https' and (u.hostname=='appinitdev.com' or (u.hostname or '').endswith('.appinitdev.com')) and not u.username and not u.password

def build_graph(root):
    data=root/'datos';ident=load(data/'identidad.json',{})
    apps=load(data/'apps.json',{}).get('items',[])
    docs=load(data/'conocimiento.json',{}).get('items',[])
    topics=load(data/'busqueda/temas.json',{}).get('items',[])
    indexed=load(data/'busqueda/documentos.json',{}).get('items',[])
    social=ident.get('redes_sociales_declaradas',[])
    org=ident.get('organizacion',{})
    developer=ident.get('desarrollador',{})
    nodes=[{'id':'organizacion:appinitdev','tipo':'organizacion','nombre':org.get('nombre','AppInitDev'),'url':'https://appinitdev.com/','fuente':'identidad.json'}]
    edges=[]
    def edge(frm,to,relation,source,certainty='declarada'):
        edges.append({'origen':frm,'destino':to,'relacion':relation,'fuente':source,'evidencia':certainty})
    if developer.get('nombre'):
        nodes.append({'id':'persona:desarrollador','tipo':'desarrollador','nombre':developer['nombre'],'fuente':developer.get('fuente','humans.txt')})
        edge('persona:desarrollador','organizacion:appinitdev','responsable_de','humans.txt')
    gp=ident.get('google_play',{}).get('perfil_desarrollador')
    if isinstance(gp,str) and gp.startswith('https://play.google.com/store/apps/dev?'):
        nodes.append({'id':'googleplay:desarrollador','tipo':'perfil_google_play','nombre':'AppInitDev en Google Play','url':gp,'fuente':'identidad.json'})
        edge('organizacion:appinitdev','googleplay:desarrollador','enlaza_perfil','identidad.json')
    for idx,s in enumerate(social):
        u=s.get('url')
        if not isinstance(u,str) or not u.startswith('https://'):continue
        sid='red:'+str(idx)
        nodes.append({'id':sid,'tipo':'red_social','nombre':s.get('plataforma','Red social'),'url':u,'fuente':'sameAs del index','verificacion':'declarada_no_comprobada'})
        edge('organizacion:appinitdev',sid,'declara_perfil','index.html sameAs')
    doclinks=[]; app_graph=[]
    for a in apps:
        pkg=a.get('id')
        if not pkg or not re.fullmatch(r'[A-Za-z0-9_]+(?:\.[A-Za-z0-9_]+)+',pkg):continue
        slug=a.get('slug','');aid='app:'+pkg
        nodes.append({'id':aid,'tipo':'aplicacion','nombre':a.get('nombre'),'paquete':pkg,'url':a.get('url'),'play_store':a.get('play_store'),'fuente':'apps.json'})
        edge('organizacion:appinitdev',aid,'publica_en_catalogo','apps_full_data.json')
        # Relación con documento SOLO si su ruta contiene literalmente slug/paquete, sin inferir funciones.
        matching=[]
        token=re.compile(r'(?<![a-z0-9])'+re.escape(slug.lower())+r'(?![a-z0-9])') if len(slug)>3 else None
        for d in docs:
            url=d.get('url','');route=urlsplit(url).path.lower()
            if token and token.search(route) and valid_app_url(url):
                matching.append({'titulo':d.get('titulo',''),'url':url,'evidencia':'slug_en_ruta'})
        matching=matching[:12]
        for m in matching:
            edge(aid,'articulo:'+m['url'],'mencion_en_ruta','conocimiento.json','heuristica_de_ruta')
            doclinks.append(m['url'])
        app_graph.append({'id':aid,'nombre':a.get('nombre'),'slug':slug,'paquete':pkg,'url':a.get('url'),'play_store':a.get('play_store'),'documentos_relacionados':matching,'relacion':'app_declarada_en_catalogo'})
    topic_ids={t.get('id') for t in topics if t.get('id')}
    for t in topics:
        tid=t.get('id')
        if tid:nodes.append({'id':'tema:'+tid,'tipo':'tema','nombre':t.get('nombre'),'fuente':'busqueda/temas.json','clasificacion':'automatica'})
    for d in indexed[:10000]:
        u=d.get('url','')
        if not valid_app_url(u):continue
        did='articulo:'+u
        nodes.append({'id':did,'tipo':'documento','nombre':d.get('titulo'),'url':u,
                      'fuente':'busqueda/documentos.json','procedencia_texto':d.get('procedencia_texto','solo_metadatos')})
        edge('organizacion:appinitdev',did,'incluye_en_catalogo','busqueda/documentos.json', 'declarada_en_catalogo')
        for tag in d.get('temas',[])[:4]:
            if tag in topic_ids:edge(did,'tema:'+tag,'clasificado_como','busqueda/documentos.json','clasificacion_heuristica')
    summary={'version':'3.0','generado_utc':NOW(),'nodos':len(nodes),'relaciones':len(edges),'apps':len(app_graph),'documentos':len(indexed),'temas':len(topics),'redes_declaradas':len(social),
      'documentos_relacionados_por_slug':len(set(doclinks)),'advertencia':'Relaciones entre apps y artículos inferidas SOLO por slug en ruta; no prueban funcionalidades ni titularidad de redes externas.'}
    save(data/'relaciones/grafo.json',{'resumen':summary,'nodos':nodes,'relaciones':edges})
    save(data/'relaciones/apps.json',{'version':'3.0','items':app_graph,'total':len(app_graph)})
    save(data/'relaciones/resumen.json',summary)
    return summary

HTML_LANG=re.compile(r'<html\b[^>]*\blang\s*=\s*[\'\"]?([a-z]{2,3}(?:-[a-zA-Z0-9]{2,8})*)',re.I)
def file_for_url(root,url):
    u=urlsplit(url);route=u.path
    if u.hostname!='appinitdev.com':return None
    if '..' in Path(route).parts:return None
    possibilities=[root/'index.html'] if route=='/' else [root/(route.strip('/')+'/index.html'),root/(route.strip('/')+'.html')]
    for p in possibilities:
        if p.is_file() and p.stat().st_size<=1_600_000 and p.resolve().is_relative_to(root.resolve()):return p
    return None

def build_languages(root):
    docs=load(root/'datos/busqueda/documentos.json',{}).get('items',[])
    public=[]; count=Counter()
    for d in docs:
        path=file_for_url(root,d.get('url','')) if d.get('texto_completo_indexado') else None
        lang='no_determinado'; source='sin_atributo_lang_verificado'
        if path:
            head=path.read_text(encoding='utf8',errors='replace')[:1500]
            match=HTML_LANG.search(head)
            if match:
                lang=match.group(1).lower(); source='html_lang_local'
        count[lang]+=1
        public.append({'url':d.get('url'),'idioma':lang,'evidencia':source})
    summary={'version':'3.0','generado_utc':NOW(),'documentos':len(public),'por_idioma':dict(count),'metodo':'atributo lang del HTML local; no crea traducciones','advertencia':'no_determinado NO significa español. La lengua del título no es prueba de traducción.'}
    save(root/'datos/idiomas/resumen.json',summary)
    save(root/'datos/idiomas/documentos.json',{'items':public})
    return summary

def read_csv_json(path):
    if path.suffix.lower()=='.json':
        dat=load(path,[])
        if isinstance(dat,dict):dat=dat.get('listings') or dat.get('items') or dat.get('data') or []
        return dat if isinstance(dat,list) else []
    if path.suffix.lower()=='.csv':
        with path.open(encoding='utf-8-sig',newline='') as f:return list(csv.DictReader(f))
    return []

def compare_play(root):
    apps=load(root/'datos/apps.json',{}).get('items',[])
    original=load(root/'apps_full_data.json',[])
    by_pkg={x.get('appId'):x for x in original if isinstance(x,dict)} if isinstance(original,list) else {}
    exports=MOD/'importaciones/google_play'
    files=sorted([*exports.glob('*.csv'),*exports.glob('*.json')]) if exports.exists() else []
    entries=[]; ignored=0
    for file in files:
        if file.stat().st_size>15_000_000:ignored+=1;continue
        for r in read_csv_json(file):
            if not isinstance(r,dict):continue
            p=str(r.get('packageName') or r.get('package_name') or r.get('package') or r.get('appId') or '')
            lang=str(r.get('language') or r.get('locale') or '').lower()
            if not re.fullmatch(r'[A-Za-z0-9_]+(?:\.[A-Za-z0-9_]+)+',p) or not re.fullmatch(r'[a-z]{2,3}(?:-[a-z0-9]{2,8})?',lang):ignored+=1;continue
            entries.append({'package':p,'idioma':lang,'titulo':str(r.get('title') or r.get('titulo') or ''),
                'resumen':str(r.get('shortDescription') or r.get('short_description') or r.get('summary') or ''),
                'descripcion':str(r.get('fullDescription') or r.get('full_description') or r.get('description') or ''),'archivo':file.name})
    comparisons=[]
    for app in apps:
        variants=[e for e in entries if e['package']==app['id']]
        primary=next((e for loc in ['es-419','es-es','en-us'] for e in reversed(variants) if e['idioma']==loc),None)
        status='sin_exportacion' if not variants else 'comparada'
        base=by_pkg.get(app['id'],{})
        diff=[]
        if primary:
            for k,col in [('title','titulo'),('summary','resumen'),('description','descripcion')]:
                old=str(base.get(k) or '').strip();new=primary[col].strip()
                if old and new and norm(old)!=norm(new):diff.append(k)
        comparisons.append({'paquete':app['id'],'nombre_catalogo':app['nombre'],'idiomas_en_exportacion':sorted({v['idioma'] for v in variants}),
                           'idioma_comparado':primary['idioma'] if primary else None,'estado':status,'campos_con_diferencias':diff})
    public={'version':'3.0','generado_utc':NOW(),'apps_catalogo':len(apps),'apps_con_exportacion':sum(x['estado']=='comparada' for x in comparisons),
      'total_fichas_localizadas':len(entries),'apps_con_diferencias':sum(bool(x['campos_con_diferencias']) for x in comparisons),
      'estado':'sin_datos_externos' if not entries else 'comparacion_con_exportaciones',
      'advertencia':'No se ha comprobado en vivo la tienda ni los estados de publicación. Diferencias comparadas contra catálogo local, no contra Play Console en tiempo real.'}
    save(root/'datos/play-store/resumen.json',public)
    save(MOD/'reportes/play_comparacion_privada.json',{'resumen':public,'detalle':comparisons,'registros_ignorados':ignored,'archivos':[p.name for p in files]})
    return public

def impact(root):
    imports=MOD/'importaciones/impacto';files=sorted([*imports.glob('*.csv'),*imports.glob('*.json')]) if imports.exists() else []
    summary={'version':'3.0','generado_utc':NOW(),'estado':'sin_importaciones','fuentes':{},'filas_validas':0,
             'advertencia':'MCP llamadas != citas de IA. Google Search Console clics e impresiones no equivalen a citas. El usuario debe indicar la fuente y periodo.'}
    private=[]; sources={}; counters=Counter()
    for path in files:
        if path.stat().st_size>15_000_000:continue
        lower=path.name.lower()
        source='bing_ai_performance' if lower.startswith('bing_ai_') else 'search_console' if lower.startswith('gsc_') else None
        if not source:continue
        rows=read_csv_json(path); rows=rows[:50000];valid=0
        for r in rows:
            if not isinstance(r,dict):continue
            # No inferir métricas a partir de columnas que no sean explícitas.
            for key,target in (('Citations','citas'),('Cited pages','paginas_citadas'),('Clicks','clics'),('Impressions','impresiones')):
                val=r.get(key) if key in r else r.get(key.lower())
                if val is None:continue
                try:num=int(str(val).replace(',','').strip())
                except ValueError:continue
                if num<0:continue
                if key in ('Citations','Cited pages') and source!='bing_ai_performance':continue
                valid+=1;counters[(source,target)]+=num
        if valid:
            private.append({'archivo':path.name,'fuente':source,'valores_numericos_validos':valid})
            sources[source]=sources.get(source,0)+valid
    if private:
        summary.update({'estado':'importacion_agregada','fuentes':sources,'filas_validas':sum(sources.values()),'totales':{f'{s}_{k}':v for (s,k),v in counters.items()},
           'advertencia':'Agregados de exportaciones locales, no verificados contra la plataforma. No sumar archivos con periodos solapados. Citas Bing y métricas GSC son indicadores diferentes.'})
    save(root/'datos/impacto/resumen.json',summary)
    save(MOD/'reportes/impacto_privado.json',{'resumen':summary,'archivos_procesados':private})
    return summary

def recognition(root):
    apps=load(root/'datos/apps.json',{}).get('items',[])
    identity=load(root/'datos/identidad.json',{})
    pairs=[]
    pair=lambda q,method,exp: pairs.append({'pregunta':q,'metodo_mcp':method,'esperado':exp})
    for a in apps:
        name=a['nombre'];pkg=a['id'];url=a['play_store'];slug=a['slug']
        pair(f'¿Qué app de AppInitDev se llama {name}?','obtener_app',{'paquete':pkg})
        pair(f'¿Dónde descargar {name} de AppInitDev?','obtener_app',{'play_store':url})
        pair(f'¿Cuál es el paquete Android de {name}?','obtener_app',{'slug':slug})
    for q in ['¿Quién es AppInitDev?','¿Quién es el desarrollador declarado?','¿Cuál es el sitio oficial?','¿Cuál es el perfil Google Play?','¿Qué organización publica las apps?']:
        pair(q,'obtener_identidad',{'organizacion':'AppInitDev'})
    for q in ['¿Cuáles son las redes sociales declaradas?','¿Tiene perfil X?','¿Cómo encuentro sus cuentas sociales?']:
        pair(q,'listar_redes_sociales',{'campo':'redes_sociales_declaradas'})
    for q in ['¿Cuántas apps hay en el catálogo?','¿Cuáles son sus apps?','¿Quién publica esas apps?']:
        pair(q,'listar_apps_desarrollador',{'conteo':len(apps)})
    # No evaluar respuestas de un modelo externo: comprobar únicamente datos y enlaces que lo respaldarían.
    results=[];ids={a['id']:a for a in apps}
    for p in pairs:
        e=p['esperado'];app=ids.get(e.get('paquete','')) or next((a for a in apps if a.get('play_store')==e.get('play_store') or a.get('slug')==e.get('slug')),None)
        if p['metodo_mcp']=='obtener_app':ok=bool(app and app.get('play_store','').startswith('https://play.google.com/store/apps/details?id=') and app.get('id'))
        elif p['metodo_mcp']=='obtener_identidad':ok=bool(identity.get('organizacion',{}).get('nombre') and identity.get('google_play',{}).get('perfil_desarrollador'))
        elif p['metodo_mcp']=='listar_redes_sociales':ok=isinstance(identity.get('redes_sociales_declaradas'),list)
        else:ok=len(apps)>0
        results.append({**p,'datos_para_responder':ok})
    summary={'version':'3.0','generado_utc':NOW(),'preguntas':len(results),'cubiertas_por_datos':sum(x['datos_para_responder'] for x in results),'sin_cobertura':sum(not x['datos_para_responder'] for x in results),
        'estado':'pruebas_deterministas_de_datos','advertencia':'Esto NO prueba reconocimiento en ChatGPT/Gemini ni verifica ejecuciones remotas de MCP; solo comprueba que existen datos para las respuestas.'}
    save(root/'datos/reconocimiento/resumen.json',summary)
    save(MOD/'reportes/reconocimiento_100_preguntas.json',{'resumen':summary,'casos':results})
    return summary

def main(root):
    root=Path(root).resolve()
    assert (root/'datos/identidad.json').is_file(),'Ejecutar primero INSTALAR_IA.py'
    for name,fn in [('grafo',build_graph),('idiomas',build_languages),('play',compare_play),('impacto',impact),('reconocimiento',recognition)]:
        d=fn(root);print(name,':',d.get('apps',d.get('documentos',d.get('preguntas',d.get('estado')))))

if __name__=='__main__':
    import sys
    main(Path(sys.argv[1]) if len(sys.argv)>1 else MOD.parent)