auto-sync: tudo-para-ia-mais-humana 2026-05-02 02:45:08

src/mais_humana/cli.py

@@ -10,9 +10,19 @@ from .models import as_plain_data
 from .central_consolidation import run_consolidated_report
 from .matrix import build_global_recommendations, build_matrix, build_platform_reports
 from .mcp_contract import build_mcp_contract_report, build_mcp_execute_probe, mcp_provider_compact_json, mcp_provider_payload
+from .mcp_contract import (
+    administration_route_readiness_markdown,
+    administration_route_readiness_payload,
+    mcp_contract_csv,
+    mcp_contract_markdown,
+    mcp_execute_probe_markdown,
+    official_report_models_markdown,
+    same_source_validation_payload,
+    ui_renderer_policy_markdown,
+)
 from .mcp_gateway_access_policy import run_access_policy_gate
 from .mcp_publication_gate import run_publication_gate
-from .mcp_transit_ledger import build_mcp_transit_ledger, mcp_transit_ledger_compact_json
+from .mcp_transit_ledger import build_mcp_transit_ledger, mcp_transit_csv, mcp_transit_ledger_compact_json, mcp_transit_markdown
 from .operational_dossier import build_execution_round_dossier
 from .governance_engine import build_governance_portfolio, compact_governance_payload
 from .human_rulebook import evaluate_rulebook, rulebook_compact_json
@@ -78,6 +88,10 @@ def build_parser() -> argparse.ArgumentParser:
     mcp_transit = sub.add_parser("mcp-transit-ledger", help="Print compact MCP transit ledger for Mais Humana contracts.")
     mcp_transit.add_argument("--ecosystem-root", default="G:/_codex-git")
     mcp_transit.add_argument("--limit", type=int, default=80)
+    mcp_artifacts = sub.add_parser("mcp-contract-artifacts", help="Write focused MCP contract artifacts without regenerating DOCX reports.")
+    mcp_artifacts.add_argument("--ecosystem-root", default="G:/_codex-git")
+    mcp_artifacts.add_argument("--project-root", default="G:/_codex-git/tudo-para-ia-mais-humana")
+    mcp_artifacts.add_argument("--central-platform-folder", default="")
     repo_mesh = sub.add_parser("repo-mesh", help="Inventory repository mirrors and write safe synchronization artifacts.")
     repo_mesh.add_argument("--ecosystem-root", default="G:/_codex-git")
     repo_mesh.add_argument("--project-root", default="G:/_codex-git/tudo-para-ia-mais-humana")
@@ -256,6 +270,68 @@ def command_mcp_transit_ledger(args: argparse.Namespace) -> int:
     return 0
 
 
+def _write_json(path: Path, payload: object) -> str:
+    from .models import as_plain_data
+
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_text(json.dumps(as_plain_data(payload), ensure_ascii=False, indent=2, sort_keys=True), encoding="utf-8")
+    return str(path)
+
+
+def _write_text(path: Path, text: str) -> str:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_text(text, encoding="utf-8")
+    return str(path)
+
+
+def command_mcp_contract_artifacts(args: argparse.Namespace) -> int:
+    project_root = Path(args.project_root)
+    central = Path(args.central_platform_folder) if args.central_platform_folder else None
+    scans = scan_ecosystem(Path(args.ecosystem_root))
+    cells = build_matrix(scans)
+    reports = build_platform_reports(scans, cells)
+    rulebook = evaluate_rulebook(reports)
+    contracts = build_mcp_contract_report(rulebook)
+    ledger = build_mcp_transit_ledger(contracts)
+    admin_routes = administration_route_readiness_payload()
+    probe = build_mcp_execute_probe(contracts)
+    written = [
+        _write_json(project_root / "dados" / "mcp-contratos-humanos.json", contracts),
+        _write_json(project_root / "dados" / "mcp-provider-mais-humana.json", mcp_provider_payload(contracts)),
+        _write_json(project_root / "dados" / "mcp-provider-mais-humana-compacto.json", mcp_provider_compact_json(contracts)),
+        _write_json(project_root / "dados" / "mcp-execute-probe-mais-humana.json", probe),
+        _write_json(project_root / "dados" / "mcp-admin-ui-same-source-validation.json", same_source_validation_payload(contracts)),
+        _write_json(project_root / "dados" / "mcp-transit-ledger.json", ledger),
+        _write_json(project_root / "dados" / "mcp-transit-ledger-compacto.json", mcp_transit_ledger_compact_json(ledger)),
+        _write_json(project_root / "dados" / "mcp-administration-routes-readiness.json", admin_routes),
+        _write_text(project_root / "ecossistema" / "MCP-PROVIDER-MAIS-HUMANA.md", mcp_contract_markdown(contracts)),
+        _write_text(project_root / "ecossistema" / "MCP-EXECUTE-PROBE-MAIS-HUMANA.md", mcp_execute_probe_markdown(probe)),
+        _write_text(project_root / "ecossistema" / "MCP-TRANSIT-LEDGER.md", mcp_transit_markdown(ledger)),
+        _write_text(project_root / "ecossistema" / "MCP-ADMINISTRATION-ROUTES.md", administration_route_readiness_markdown(admin_routes)),
+        _write_text(project_root / "ecossistema" / "MODELOS-OFICIAIS-RELATORIO-HUMANO.md", official_report_models_markdown(contracts)),
+        _write_text(project_root / "ecossistema" / "UI-RENDERER-SAME-SOURCE-POLICY.md", ui_renderer_policy_markdown(contracts)),
+        _write_text(project_root / "matrizes" / "mcp-contratos-humanos.csv", mcp_contract_csv(contracts)),
+        _write_text(project_root / "matrizes" / "mcp-transit-ledger.csv", mcp_transit_csv(ledger)),
+    ]
+    central_error = ""
+    if central is not None:
+        try:
+            written.append(_write_text(central / "reports" / "EXECUTADO__mcp-contract-artifacts.md", mcp_contract_markdown(contracts)))
+            written.append(_write_text(central / "indexes" / "mcp-administration-routes-index.md", administration_route_readiness_markdown(admin_routes)))
+        except OSError as exc:
+            central_error = f"{type(exc).__name__}: {exc}"
+    payload = {
+        "contractsCount": contracts.contracts_count,
+        "coverageCount": len(contracts.coverage),
+        "transitRecords": ledger.records_count,
+        "administrationRoutes": admin_routes["contractsCount"],
+        "centralError": central_error,
+        "generatedFiles": written,
+    }
+    print(json.dumps(payload, ensure_ascii=False, indent=2))
+    return 0
+
+
 def command_repo_mesh(args: argparse.Namespace) -> int:
     central = Path(args.central_platform_folder) if args.central_platform_folder else None
     central_write_error = ""
@@ -485,6 +561,8 @@ def main(argv: list[str] | None = None) -> int:
         return command_mcp_execute_probe(args)
     if args.command == "mcp-transit-ledger":
         return command_mcp_transit_ledger(args)
+    if args.command == "mcp-contract-artifacts":
+        return command_mcp_contract_artifacts(args)
     if args.command == "repo-mesh":
         return command_repo_mesh(args)
     if args.command == "consolidated-report":

src/mais_humana/mcp_contract.py

@@ -360,6 +360,46 @@ def administration_route_readiness_payload(
     }
 
 
+def administration_route_readiness_markdown(payload: Mapping[str, Any]) -> str:
+    """Render MCP administration route readiness as a human audit document."""
+
+    lines = [
+        "# MCP Administration Routes Readiness",
+        "",
+        f"- provider_id: `{payload.get('providerId', '')}`",
+        f"- control_plane_id: `{payload.get('controlPlaneId', '')}`",
+        f"- contracts_count: `{payload.get('contractsCount', 0)}`",
+        f"- platforms_count: `{payload.get('platformsCount', 0)}`",
+        f"- profiles_count: `{payload.get('profilesCount', 0)}`",
+        f"- all_routes_same_source_ready: `{payload.get('allRoutesSameSourceReady')}`",
+        f"- evidence_id: `{payload.get('evidenceId', '')}`",
+        "",
+        "## Operacoes",
+        "",
+    ]
+    operations = payload.get("operations") or {}
+    if isinstance(operations, Mapping) and operations:
+        lines.extend(f"- `{name}`: `{count}`" for name, count in sorted(operations.items()))
+    else:
+        lines.append("- Nenhuma rota administrativa encontrada.")
+    blocked = payload.get("blockedRoutes") or []
+    lines.extend(["", "## Bloqueios", ""])
+    if blocked:
+        lines.extend(f"- `{item}`" for item in blocked[:40])
+    else:
+        lines.append("- Nenhum bloqueio de same-source nas rotas administrativas avaliadas.")
+    lines.extend(
+        [
+            "",
+            "## Regra MCP-only",
+            "",
+            "- Consulta, diagnostico, acao, auditoria e explicacao devem passar pelo MCPs Internos.",
+            "- Rotas diretas de administracao da plataforma sao bloqueadas quando nao deixam traceId, auditId e permissionScope.",
+        ]
+    )
+    return "\n".join(lines).strip() + "\n"
+
+
 def _rulebook_platform_truth(rulebook: RulebookReport | None) -> dict[str, TruthState]:
     if rulebook is None:
         return {}

tests/test_mcp_provider_contract.py

@@ -13,6 +13,7 @@ from mais_humana.mcp_contract import (
     MCP_CONTROL_PLANE_ID,
     McpContractKind,
     administration_route_contracts,
+    administration_route_readiness_markdown,
     administration_route_readiness_payload,
     build_mcp_contract_report,
     build_mcp_execute_probe,
@@ -138,6 +139,9 @@ class McpProviderContractTests(unittest.TestCase):
         self.assertEqual(readiness["kind"], "administration_route")
         self.assertEqual(set(readiness["operations"].keys()), operations)
         self.assertTrue(readiness["evidenceId"].startswith("evidence-"))
+        markdown = administration_route_readiness_markdown(readiness)
+        self.assertIn("MCP Administration Routes Readiness", markdown)
+        self.assertIn("Regra MCP-only", markdown)
 
     def test_cli_mcp_provider_returns_json(self) -> None:
         root = make_tmp()
@@ -151,6 +155,22 @@ class McpProviderContractTests(unittest.TestCase):
         probe_code = main(["mcp-execute-probe", "--ecosystem-root", str(root), "--limit", "3", "--observed-status", "prepared"])
         self.assertEqual(probe_code, 0)
 
+    def test_cli_mcp_contract_artifacts_writes_focused_outputs(self) -> None:
+        root = make_tmp()
+        project = root / "tudo-para-ia-mais-humana"
+        self.make_repo(
+            root,
+            "business",
+            "business checkout billing entitlements sameSource panelReady responseReady traceId auditId",
+        )
+        code = main(["mcp-contract-artifacts", "--ecosystem-root", str(root), "--project-root", str(project)])
+        self.assertEqual(code, 0)
+        provider = json.loads((project / "dados" / "mcp-provider-mais-humana-compacto.json").read_text(encoding="utf-8"))
+        admin_routes = json.loads((project / "dados" / "mcp-administration-routes-readiness.json").read_text(encoding="utf-8"))
+        self.assertGreaterEqual(provider["contractsCount"], 2000)
+        self.assertGreaterEqual(admin_routes["contractsCount"], 900)
+        self.assertTrue((project / "ecossistema" / "MCP-ADMINISTRATION-ROUTES.md").exists())
+
     def test_provider_payload_is_serializable(self) -> None:
         report = self.make_report(make_tmp())
         payload = mcp_provider_payload(report, limit=3)