From dfb00b2f03213c572871878f066812cf5448ba64 Mon Sep 17 00:00:00 2001 From: codex-server Date: Sat, 2 May 2026 02:45:08 -0300 Subject: [PATCH] auto-sync: tudo-para-ia-mais-humana 2026-05-02 02:45:08 --- src/mais_humana/cli.py | 80 ++++++++++++++++++++++++++++- src/mais_humana/mcp_contract.py | 40 +++++++++++++++ tests/test_mcp_provider_contract.py | 20 ++++++++ 3 files changed, 139 insertions(+), 1 deletion(-) diff --git a/src/mais_humana/cli.py b/src/mais_humana/cli.py index 5145693..855f5fb 100644 --- a/src/mais_humana/cli.py +++ b/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": diff --git a/src/mais_humana/mcp_contract.py b/src/mais_humana/mcp_contract.py index ea8b577..7980fb7 100644 --- a/src/mais_humana/mcp_contract.py +++ b/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 {} diff --git a/tests/test_mcp_provider_contract.py b/tests/test_mcp_provider_contract.py index bcb5812..f8bbc17 100644 --- a/tests/test_mcp_provider_contract.py +++ b/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)