fix(scanner-v4): indentation fixed, TeleologicalScanner funcionando para todos os 3 objetivos

Author: marce

skills/system/academic-audit/teleological_scanner.py

@@ -0,0 +1,393 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+TeleologicalScanner v1.0 — Scanner Noologico Reverso (v4.0)
+=============================================================
+Conceito original: interlocutor anonimo (2026)
+Implementacao: Marcelo Claro Laranjeira
+
+Progressao completa do Scanner Noologico:
+  v1.0 — ERRO:      "O que esta errado?"      (Popper)
+  v2.0 — AUSENCIA:  "O que esta ausente?"      (Bachelard)
+  v3.0 — OPORTUNIDADE: "Onde investir?"         (Kauffman)
+  v4.0 — TELEOLOGIA:   "O que precisa existir?"  (Aristoteles/Polya)
+
+Principio: Em vez de analisar o estado atual para descobrir ausencias,
+o Scanner Reverso parte de um ESTADO FUTURO DESEJADO e decompoe,
+por engenharia reversa, quais capacidades, estruturas e componentes
+precisariam existir para que aquele estado fosse alcancavel.
+
+Fluxo conceitual:
+  Estado Futuro Desejado
+       ↓ (decomposicao teleologica)
+  Capacidades Necessarias
+       ↓ (mapeamento estrutural)
+  Estruturas Necessarias
+       ↓ (mapeamento componencial)
+  Componentes Necessarios
+       ↓ (comparacao com estado atual)
+  Lacunas de Evolucao (roadmap priorizado)
+
+Formalismo matematico:
+  - AND-OR trees para decomposicao de objetivos complexos
+  - Minimum Spanning Capability Set (MSCS)
+  - Gap Score = f(importancia, dependencia, viabilidade)
+
+Uso:
+  from teleological_scanner import TeleologicalScanner
+  scanner = TeleologicalScanner()
+  roadmap = scanner.scan("AGI com alinhamento humano")
+"""
+
+from __future__ import annotations
+
+import json
+from dataclasses import dataclass, field
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Any
+
+BRAZIL_TZ = timezone.utc
+
+
+@dataclass
+class Capability:
+    """Uma capacidade necessaria para atingir o estado futuro."""
+    name: str
+    description: str = ""
+    dependencies: list[str] = field(default_factory=list)
+    priority: int = 1  # 1=critico, 2=importante, 3=desejavel
+    exists: bool = False
+    gap_score: float = 0.0  # 0-100: quao longe estamos de te-la
+
+
+@dataclass
+class EvolutionGap:
+    """Uma lacuna de evolucao — capacidade ausente que precisa ser desenvolvida."""
+    capability: str
+    priority: int
+    gap_score: float
+    prerequisites: list[str] = field(default_factory=list)
+    estimated_effort: str = ""
+    rationale: str = ""
+
+
+# ═══════════════════════════════════════════════════════════════════════
+# GOAL DECOMPOSITION TREES (AND-OR)
+# ═══════════════════════════════════════════════════════════════════════
+
+GOAL_TREES: dict[str, dict[str, Any]] = {
+    "AGI": {
+        "description": "Inteligencia Artificial Geral com alinhamento humano",
+        "capabilities": {
+            "raciocinio_abstrato": {
+                "desc": "Capacidade de raciocinio abstrato cross-domain",
+                "deps": ["transfer_learning", "analogical_reasoning"],
+                "priority": 1,
+            },
+            "aprendizado_continuo": {
+                "desc": "Aprendizado continuo sem esquecimento catastrofico",
+                "deps": ["memory_consolidation", "online_learning"],
+                "priority": 1,
+            },
+            "alinhamento_valores": {
+                "desc": "Alinhamento robusto com valores humanos",
+                "deps": ["value_learning", " corrigibility", "interpretability"],
+                "priority": 1,
+            },
+            "autoaperfeicoamento": {
+                "desc": "Capacidade de melhorar o proprio codigo/arquitetura",
+                "deps": ["meta_learning", "self_verification"],
+                "priority": 2,
+            },
+            "consciencia_situacional": {
+                "desc": "Compreensao do proprio estado, capacidades e limitacoes",
+                "deps": ["self_modeling", "uncertainty_quantification"],
+                "priority": 2,
+            },
+            "comunicacao_natural": {
+                "desc": "Comunicacao em linguagem natural multi-contexto",
+                "deps": ["pragmatics", "common_sense", "theory_of_mind"],
+                "priority": 2,
+            },
+            "criatividade": {
+                "desc": "Geracao de ideias genuinamente novas",
+                "deps": ["divergent_thinking", "conceptual_blending"],
+                "priority": 3,
+            },
+        }
+    },
+    "artigo_qualis_a1": {
+        "description": "Artigo cientifico com score >= 95/100 nos criterios Qualis/CAPES",
+        "capabilities": {
+            "pesquisa_bibliografica": {
+                "desc": "Busca exaustiva em 10+ fontes academicas",
+                "deps": ["seeker_multi_source", "doi_verification"],
+                "priority": 1,
+            },
+            "rigor_metodologico": {
+                "desc": "Metodologia explicitamente fundamentada",
+                "deps": ["paradigm_selection", "method_justification"],
+                "priority": 1,
+            },
+            "rastreabilidade": {
+                "desc": "Toda afirmacao vinculada a evidencia verificavel",
+                "deps": ["academic_audit_trail", "doi_linking"],
+                "priority": 1,
+            },
+            "anti_ia_compliance": {
+                "desc": "Zero violacoes TSAC (87 palavras banidas)",
+                "deps": ["tsac_check", "anti_ia_score"],
+                "priority": 1,
+            },
+            "cobertura_epistemologica": {
+                "desc": "Alta cobertura no Scanner Noologico",
+                "deps": ["noological_scanner", "eps_estimator"],
+                "priority": 2,
+            },
+            "dialogo_interdisciplinar": {
+                "desc": "Dialogo entre diferentes tradicoes teoricas",
+                "deps": ["cross_domain_analysis", "game_theory_integration"],
+                "priority": 2,
+            },
+        }
+    },
+    "ecossistema_autonomo": {
+        "description": "Ecossistema cientifico com autonomia nivel 4 (auto-evolucao)",
+        "capabilities": {
+            "auto_discovery": {
+                "desc": "Descoberta automatica de novas ferramentas e bibliotecas",
+                "deps": ["pypi_scout", "auto_install"],
+                "priority": 1,
+            },
+            "auto_healing": {
+                "desc": "Deteccao e reparo automatico de falhas",
+                "deps": ["self_healer", "health_monitor"],
+                "priority": 1,
+            },
+            "auto_evolution": {
+                "desc": "Geracao automatica de novas skills a partir de padroes",
+                "deps": ["manus_evolve", "pattern_extraction"],
+                "priority": 1,
+            },
+            "auto_audit": {
+                "desc": "Auditoria continua e automatica de toda producao",
+                "deps": ["interaction_logger", "academic_audit_trail"],
+                "priority": 1,
+            },
+            "auto_scan": {
+                "desc": "Scanner epistemologico executado a cada publicacao",
+                "deps": ["scanner_integration", "eps_estimator"],
+                "priority": 2,
+            },
+            "auto_roadmap": {
+                "desc": "Geracao automatica de roadmap de evolucao",
+                "deps": ["teleological_scanner", "gap_analyzer"],
+                "priority": 2,
+            },
+        }
+    },
+}
+
+
+class TeleologicalScanner:
+    """Scanner Noologico Reverso (v4.0).
+
+    Decompoe um estado futuro desejado em capacidades necessarias,
+    mapeia-as para o estado atual, e gera um roadmap de evolucao
+    priorizado por importancia, dependencia e viabilidade.
+
+    Uso:
+        scanner = TeleologicalScanner()
+        roadmap = scanner.scan("AGI")
+        scanner.save_roadmap(roadmap, "roadmap_agi.md")
+    """
+
+    def scan(self, goal: str, current_capabilities: list[str] | None = None) -> dict[str, Any]:
+        """Executa decomposicao teleologica de um objetivo.
+
+        Args:
+            goal: Objetivo (ex: "AGI", "artigo_qualis_a1", "ecossistema_autonomo")
+            current_capabilities: Capacidades ja existentes (se None, usa defaults)
+
+        Returns:
+            Roadmap com capacidades, gaps e prioridades
+        """
+        # Normalizar goal
+        goal_key = goal.lower().replace(" ", "_")
+        # Case-insensitive lookup
+        tree = None
+        for k, v in GOAL_TREES.items():
+            if k.lower() == goal_key or goal_key in k.lower():
+                tree = v
+                goal_key = k
+                break
+        if tree is None:
+            return {"error": f"Goal nao encontrado: {goal}. Disponiveis: {list(GOAL_TREES.keys())}"}
+        capabilities = tree["capabilities"]
+
+        # Se nao foram fornecidas capacidades atuais, assumir que so temos as basicas
+        if current_capabilities is None:
+            # Simular estado atual do ecossistema
+            current_capabilities = [
+                "seeker_multi_source", "doi_verification", "academic_audit_trail",
+                "tsac_check", "anti_ia_score", "pypi_scout", "self_healer",
+                "interaction_logger", "scanner_integration", "eps_estimator",
+                "manus_evolve", "auto_install", "health_monitor",
+            ]
+
+        current_set = set(current_capabilities)
+
+        # Analisar cada capacidade
+        gaps = []
+        covered = []
+        total_deps = 0
+        covered_deps = 0
+
+        for cap_name, cap_data in capabilities.items():
+            deps = cap_data.get("deps", [])
+            total_deps += len(deps)
+            deps_covered = sum(1 for d in deps if d in current_set)
+            covered_deps += deps_covered
+
+            # Verificar se a capacidade existe (todos os deps cobertos)
+            exists = all(d in current_set for d in deps)
+            gap_score = (1 - deps_covered / max(1, len(deps))) * 100 if deps else 0
+
+            if exists:
+                covered.append(cap_name)
+            else:
+                missing_deps = [d for d in deps if d not in current_set]
+                gaps.append(EvolutionGap(
+                    capability=cap_name,
+                    priority=cap_data.get("priority", 2),
+                    gap_score=round(gap_score),
+                    prerequisites=missing_deps,
+                    estimated_effort=self._estimate_effort(gap_score),
+                    rationale=cap_data.get("desc", ""),
+                ))
+
+        # Ordenar gaps por prioridade e gap_score
+        gaps.sort(key=lambda g: (g.priority, -g.gap_score))
+
+        # Calcular progresso
+        total_caps = len(capabilities)
+        covered_caps = len(covered)
+        progress_pct = round(covered_caps / max(1, total_caps) * 100)
+        dependency_coverage = round(covered_deps / max(1, total_deps) * 100)
+
+        return {
+            "goal": goal,
+            "goal_key": goal_key,
+            "description": tree["description"],
+            "timestamp": datetime.now(BRAZIL_TZ).isoformat(),
+            "version": "4.0",
+            "total_capabilities": total_caps,
+            "covered_capabilities": covered_caps,
+            "gap_capabilities": len(gaps),
+            "progress_pct": progress_pct,
+            "dependency_coverage_pct": dependency_coverage,
+            "capabilities": {
+                "covered": covered,
+                "gaps": [
+                    {
+                        "capability": g.capability,
+                        "priority": g.priority,
+                        "gap_score": g.gap_score,
+                        "prerequisites": g.prerequisites,
+                        "estimated_effort": g.estimated_effort,
+                        "rationale": g.rationale,
+                    }
+                    for g in gaps
+                ],
+            },
+            "roadmap": self._generate_roadmap(gaps, progress_pct),
+        }
+
+    def _estimate_effort(self, gap_score: float) -> str:
+        """Estima esforco necessario baseado no gap_score."""
+        if gap_score >= 80: return "Alto (requer pesquisa fundamental)"
+        if gap_score >= 50: return "Medio (requer desenvolvimento significativo)"
+        if gap_score >= 20: return "Baixo (requer integracao de componentes existentes)"
+        return "Minimo (componentes ja disponiveis)"
+
+    def _generate_roadmap(self, gaps: list[EvolutionGap], progress: int) -> list[dict[str, Any]]:
+        """Gera roadmap priorizado em 3 fases."""
+        phases = {"Fase 1 — Imediato (0-3 meses)": [], "Fase 2 — Curto Prazo (3-12 meses)": [], "Fase 3 — Longo Prazo (12+ meses)": []}
+
+        for g in gaps:
+            if g.priority == 1 and g.gap_score < 50:
+                phases["Fase 1 — Imediato (0-3 meses)"].append(g.capability)
+            elif g.priority <= 2:
+                phases["Fase 2 — Curto Prazo (3-12 meses)"].append(g.capability)
+            else:
+                phases["Fase 3 — Longo Prazo (12+ meses)"].append(g.capability)
+
+        return [
+            {"phase": phase, "capabilities": caps, "count": len(caps)}
+            for phase, caps in phases.items() if caps
+        ]
+
+    def generate_markdown_report(self, results: dict[str, Any]) -> str:
+        """Gera relatorio Markdown do roadmap."""
+        r = results
+        lines = [
+            f"# Scanner Noologico Reverso v4.0 — Roadmap Teleologico",
+            f"",
+            f"**Objetivo**: {r['goal']}",
+            f"**Descricao**: {r['description']}",
+            f"**Data**: {r['timestamp'][:19]}",
+            f"**Progresso atual**: {r['progress_pct']}% ({r['covered_capabilities']}/{r['total_capabilities']} capacidades)",
+            f"**Cobertura de dependencias**: {r['dependency_coverage_pct']}%",
+            f"",
+            f"---",
+            f"",
+            f"## GAPS — Capacidades Ausentes ({r['gap_capabilities']})",
+            f"",
+        ]
+
+        for i, g in enumerate(r["capabilities"]["gaps"], 1):
+            priority_label = {1: "CRITICO", 2: "IMPORTANTE", 3: "DESEJAVEL"}.get(g["priority"], "?")
+            lines.append(f"### {i}. {g['capability']} [{priority_label}] — Gap Score: {g['gap_score']}%")
+            lines.append(f"")
+            lines.append(f"**Por que e necessario**: {g['rationale']}")
+            lines.append(f"**Pre-requisitos ausentes**: {', '.join(g['prerequisites']) if g['prerequisites'] else 'Nenhum'}")
+            lines.append(f"**Esforco estimado**: {g['estimated_effort']}")
+            lines.append(f"")
+
+        lines.append("---")
+        lines.append("")
+        lines.append("## Roadmap de Evolucao")
+        lines.append("")
+        for phase_data in r["roadmap"]:
+            lines.append(f"### {phase_data['phase']} ({phase_data['count']} capacidades)")
+            for cap in phase_data["capabilities"]:
+                lines.append(f"- {cap}")
+            lines.append("")
+
+        lines.append("---")
+        lines.append(f"**Progressao conceitual**: ERRO (v1) → AUSENCIA (v2) → OPORTUNIDADE (v3) → TELEOLOGIA (v4)")
+        lines.append(f"**Conceito original**: interlocutor anonimo (2026) | **Implementacao**: Marcelo Claro Laranjeira")
+
+        return "\n".join(lines)
+
+    def save_roadmap(self, results: dict[str, Any], output_path: str | Path) -> Path:
+        """Salva roadmap em disco."""
+        path = Path(output_path)
+        path.parent.mkdir(parents=True, exist_ok=True)
+        path.write_text(self.generate_markdown_report(results), encoding="utf-8")
+        return path
+
+
+# ── Teste ──
+if __name__ == "__main__":
+    scanner = TeleologicalScanner()
+
+    for goal in ["AGI", "artigo_qualis_a1", "ecossistema_autonomo"]:
+        results = scanner.scan(goal)
+        print(f"\n{'='*60}")
+        print(f"Goal: {goal}")
+        print(f"Progresso: {results['progress_pct']}% ({results['covered_capabilities']}/{results['total_capabilities']})")
+        print(f"Gaps: {results['gap_capabilities']}")
+        for g in results["capabilities"]["gaps"][:3]:
+            print(f"  [{g['priority']}] {g['capability']} — Gap: {g['gap_score']}% — {g['estimated_effort']}")