680 lines
40 KiB
Python
680 lines
40 KiB
Python
"""High-level orchestration for report generation."""
|
|
|
|
from __future__ import annotations
|
|
|
|
import json
|
|
from pathlib import Path
|
|
from typing import Sequence
|
|
|
|
from .catalog import HUMAN_PROFILES, PLATFORMS
|
|
from .charts import matrix_heatmap_svg, platform_bar_svg, profile_radar_svg
|
|
from .commands import base_validation_commands, commands_markdown, platform_validation_commands
|
|
from .contract import build_contract, contract_markdown
|
|
from .docx_writer import DocxDocument, write_lines_docx
|
|
from .acceptance import acceptance_markdown, build_acceptance_report
|
|
from .evidence_index import build_evidence_index, evidence_markdown
|
|
from .evidence_graph import build_evidence_graph
|
|
from .exit_order_compiler import compile_governance_orders, compiled_orders_markdown, order_coverage_rows, source_candidate_rows
|
|
from .governance_diff import (
|
|
diff_governance_snapshots,
|
|
governance_delta_markdown,
|
|
governance_delta_rows,
|
|
load_governance_snapshot,
|
|
snapshot_from_portfolio,
|
|
write_governance_snapshot,
|
|
)
|
|
from .governance_engine import build_governance_portfolio, rows_to_csv
|
|
from .governance_exports import governance_exports, write_central_lifecycle_exports, write_governance_exports
|
|
from .governance_scenarios import build_scenario_portfolio
|
|
from .governance_storage import write_governance_semantic_state
|
|
from .human_rulebook import evaluate_rulebook, rulebook_compact_json, rulebook_csv, rulebook_markdown
|
|
from .mcp_contract import (
|
|
build_mcp_contract_report,
|
|
mcp_contract_csv,
|
|
mcp_contract_markdown,
|
|
mcp_provider_compact_json,
|
|
mcp_provider_payload,
|
|
official_report_models_markdown,
|
|
same_source_validation_payload,
|
|
ui_renderer_policy_markdown,
|
|
)
|
|
from .human_readiness_registry import build_readiness_registry
|
|
from .matrix import build_global_recommendations, build_matrix, build_platform_reports, matrix_table
|
|
from .models import EcosystemHumanReport, GeneratedFile, PlatformHumanReport, ReportBundle, as_plain_data
|
|
from .narratives import ecosystem_markdown, ecosystem_summary_lines, platform_markdown, platform_report_lines
|
|
from .orders import audit_markdown, build_exit_orders, executed_order_markdown, pending_markdown, write_orders
|
|
from .html_export import write_index_html
|
|
from .insights import build_insights, dependency_dot, insights_markdown
|
|
from .operational_dossier import (
|
|
build_execution_round_dossier,
|
|
dossier_compact_rows,
|
|
dossier_to_markdown,
|
|
order_justifications_markdown,
|
|
write_csv_lines,
|
|
)
|
|
from .playbooks import build_playbooks, playbooks_markdown
|
|
from .portfolio_queries import build_operational_questions
|
|
from .quality import evaluate_ecosystem_quality, quality_to_markdown
|
|
from .questions import questions_for_ecosystem, questions_markdown
|
|
from .redaction import redaction_markdown, scan_generated_artifacts
|
|
from .repository_mesh import run_repository_mesh
|
|
from .repository_mesh_reconciliation import apply_reconciliation_to_report
|
|
from .repository_mesh_runtime import (
|
|
acquire_lock,
|
|
build_runtime_cycle,
|
|
cron_scheduler_spec,
|
|
release_lock,
|
|
windows_scheduler_spec,
|
|
write_runtime_artifacts,
|
|
)
|
|
from .repository_mesh_semantic import semantic_generated_records, write_repository_mesh_semantic_state
|
|
from .repository_mesh_readiness import build_mesh_readiness_report, write_readiness_artifacts
|
|
from .repository_mesh_gitea import build_gitea_mesh_plan, write_gitea_plan_artifacts
|
|
from .round_assurance import assurance_markdown, assurance_rows, build_assurance_suite
|
|
from .runtime_budget import build_round_line_budget
|
|
from .scanner import scan_ecosystem
|
|
from .snapshots import diff_snapshots, load_snapshot, snapshot_delta_markdown, snapshot_from_reports, write_snapshot
|
|
from .status_pages import write_central_status_pages
|
|
from .service_order_lifecycle import build_round_execution_package
|
|
from .status_reconciler import build_reconciled_status, write_reconciled_status
|
|
from .storage import write_semantic_state
|
|
from .workflow_registry import build_workflow_portfolio
|
|
|
|
|
|
def repo_paths(project_root: Path) -> dict[str, Path]:
|
|
return {
|
|
"platform_markdown": project_root / "plataformas",
|
|
"ecosystem": project_root / "ecossistema",
|
|
"docx_platforms": project_root / "relatorios-docx" / "plataformas",
|
|
"docx_root": project_root / "relatorios-docx",
|
|
"charts": project_root / "graficos",
|
|
"matrices": project_root / "matrizes",
|
|
"data": project_root / "dados",
|
|
"orders": project_root / "os-orientadoras",
|
|
"goals": project_root / "metas-humanas",
|
|
"questions": project_root / "pessoas-e-papeis",
|
|
"html": project_root / "ecossistema",
|
|
}
|
|
|
|
|
|
def ensure_project_dirs(project_root: Path) -> None:
|
|
for path in repo_paths(project_root).values():
|
|
path.mkdir(parents=True, exist_ok=True)
|
|
for extra in ("paradigma", "pessoas-e-papeis", "telas-e-relatorios", "templates"):
|
|
(project_root / extra).mkdir(parents=True, exist_ok=True)
|
|
|
|
|
|
def generated_file(path: Path, project_root: Path, description: str, function: str, file_type: str, relation: str) -> GeneratedFile:
|
|
try:
|
|
rel = path.relative_to(project_root)
|
|
except ValueError:
|
|
rel = path
|
|
return GeneratedFile(
|
|
path=str(rel).replace("\\", "/"),
|
|
description=description,
|
|
function=function,
|
|
file_type=file_type,
|
|
changed_by="mais_humana.generate",
|
|
change_summary=description,
|
|
relation_to_order=relation,
|
|
)
|
|
|
|
|
|
def write_json(path: Path, payload: object) -> Path:
|
|
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 path
|
|
|
|
|
|
def write_platform_docx(path: Path, report: PlatformHumanReport) -> Path:
|
|
doc = DocxDocument(title=f"Relatorio humano - {report.platform.title}")
|
|
doc.heading("Missao", 2)
|
|
doc.paragraph(report.platform.mission)
|
|
doc.heading("Sintese", 2)
|
|
doc.paragraph(report.summary)
|
|
doc.heading("Estado atual", 2)
|
|
for item in report.current_state:
|
|
doc.bullet(item)
|
|
doc.heading("Lacunas humanas", 2)
|
|
for item in report.missing_for_humans:
|
|
doc.bullet(item)
|
|
doc.heading("Matriz por perfil", 2)
|
|
rows = []
|
|
for cell in sorted(report.cells, key=lambda item: item.profile_id):
|
|
rows.append((cell.profile_id, str(cell.score), cell.maturity.value, cell.explanation[:180]))
|
|
doc.table(("Perfil", "Score", "Maturidade", "Leitura"), rows)
|
|
doc.heading("Recomendacoes", 2)
|
|
for recommendation in report.recommendations[:8]:
|
|
doc.bullet(f"{recommendation.title}: {recommendation.reason}")
|
|
return doc.write(path)
|
|
|
|
|
|
def write_ecosystem_docx(path: Path, reports: Sequence[PlatformHumanReport]) -> Path:
|
|
doc = DocxDocument(title="Relatorio Geral do Ecossistema Mais Humano")
|
|
for line in ecosystem_summary_lines(reports):
|
|
if line == "Leitura por necessidade humana":
|
|
doc.heading(line, 2)
|
|
elif line.startswith("Plataformas "):
|
|
doc.heading(line, 2)
|
|
else:
|
|
doc.paragraph(line)
|
|
rows = []
|
|
for report in sorted(reports, key=lambda item: item.platform.platform_id):
|
|
rows.append((report.platform.platform_id, str(report.average_score), str(report.scan.code_lines), str(len(report.scan.evidence))))
|
|
doc.heading("Resumo por plataforma", 2)
|
|
doc.table(("Plataforma", "Score", "Linhas", "Evidencias"), rows)
|
|
return doc.write(path)
|
|
|
|
|
|
def write_profile_catalog(project_root: Path) -> Path:
|
|
path = project_root / "pessoas-e-papeis" / "perfis-humanos.json"
|
|
return write_json(path, HUMAN_PROFILES)
|
|
|
|
|
|
def write_platform_catalog(project_root: Path) -> Path:
|
|
path = project_root / "dados" / "catalogo-plataformas.json"
|
|
return write_json(path, PLATFORMS)
|
|
|
|
|
|
def write_matrix_csv(path: Path, table: Sequence[Sequence[str]]) -> Path:
|
|
path.parent.mkdir(parents=True, exist_ok=True)
|
|
lines = []
|
|
for row in table:
|
|
escaped = []
|
|
for value in row:
|
|
text = str(value).replace('"', '""')
|
|
if "," in text or "\n" in text:
|
|
text = f'"{text}"'
|
|
escaped.append(text)
|
|
lines.append(",".join(escaped))
|
|
path.write_text("\n".join(lines) + "\n", encoding="utf-8")
|
|
return path
|
|
|
|
|
|
def write_human_goals(project_root: Path, reports: Sequence[PlatformHumanReport]) -> Path:
|
|
path = project_root / "metas-humanas" / "metas-humanas-por-plataforma.md"
|
|
lines = ["# Metas humanas por plataforma", ""]
|
|
for report in sorted(reports, key=lambda item: item.platform.platform_id):
|
|
lines.append(f"## {report.platform.title}")
|
|
lines.append("")
|
|
lines.append(f"Score atual: {report.average_score}")
|
|
lines.append("")
|
|
for gap in report.missing_for_humans[:5]:
|
|
lines.append(f"- Converter lacuna em entrega: {gap}")
|
|
lines.append("")
|
|
path.write_text("\n".join(lines), encoding="utf-8")
|
|
return path
|
|
|
|
|
|
def write_screen_report_map(project_root: Path, reports: Sequence[PlatformHumanReport]) -> Path:
|
|
path = project_root / "telas-e-relatorios" / "mapa-telas-relatorios-esperados.md"
|
|
lines = ["# Mapa de telas e relatorios esperados", ""]
|
|
for report in sorted(reports, key=lambda item: item.platform.platform_id):
|
|
lines.append(f"## {report.platform.title}")
|
|
lines.append("")
|
|
for surface in report.platform.expected_surfaces:
|
|
lines.append(f"- {surface}")
|
|
lines.append("")
|
|
path.write_text("\n".join(lines), encoding="utf-8")
|
|
return path
|
|
|
|
|
|
def write_paradigm(project_root: Path) -> Path:
|
|
path = project_root / "paradigma" / "paradigma-mais-humano.md"
|
|
text = """# Paradigma Mais Humano
|
|
|
|
A plataforma tudo-para-ia-mais-humana traduz estado tecnico em compreensao humana.
|
|
|
|
Ela pergunta:
|
|
|
|
- quem e atendido;
|
|
- como e atendido;
|
|
- o que ja funciona;
|
|
- o que ainda falta;
|
|
- qual ordem de servico melhora a experiencia real.
|
|
|
|
A plataforma nao substitui o nucleo, a central, o MCP ou a UI. Ela transforma evidencias dessas camadas em relatorios, matrizes e continuidade orientada a pessoas.
|
|
"""
|
|
path.write_text(text, encoding="utf-8")
|
|
return path
|
|
|
|
|
|
def generate(
|
|
ecosystem_root: Path,
|
|
project_root: Path,
|
|
central_platform_folder: Path | None = None,
|
|
relation_to_order: str = "0011_GERENCIAL__fundacao-da-plataforma",
|
|
push_status: str | None = None,
|
|
) -> ReportBundle:
|
|
ensure_project_dirs(project_root)
|
|
scans = scan_ecosystem(ecosystem_root)
|
|
evidence_records = build_evidence_index(scans)
|
|
cells = build_matrix(scans)
|
|
platform_reports = build_platform_reports(scans, cells)
|
|
recommendations = build_global_recommendations(platform_reports)
|
|
quality_reports = evaluate_ecosystem_quality(platform_reports)
|
|
human_questions = questions_for_ecosystem(platform_reports)
|
|
playbooks = build_playbooks(platform_reports)
|
|
insights = build_insights(platform_reports, recommendations)
|
|
command_specs = base_validation_commands(project_root, central_platform_folder) + platform_validation_commands(platform_reports)
|
|
ecosystem_report = EcosystemHumanReport(scans=scans, platform_reports=platform_reports, recommendations=recommendations)
|
|
exit_orders = build_exit_orders(recommendations)
|
|
generated: list[GeneratedFile] = []
|
|
round_dossier = build_execution_round_dossier(
|
|
project_root=project_root,
|
|
platform_reports=platform_reports,
|
|
recommendations=recommendations,
|
|
output_orders=exit_orders,
|
|
total_code_lines_analyzed=ecosystem_report.total_code_lines,
|
|
)
|
|
governance_portfolio = build_governance_portfolio(
|
|
platform_reports,
|
|
recommendations=recommendations,
|
|
round_dossier=round_dossier,
|
|
extra_text=(push_status or "",),
|
|
)
|
|
readiness_registry = build_readiness_registry(platform_reports, governance_portfolio)
|
|
workflow_portfolio = build_workflow_portfolio(governance_portfolio)
|
|
scenario_portfolio = build_scenario_portfolio(governance_portfolio)
|
|
governance_orders = compile_governance_orders(governance_portfolio)
|
|
governance_questions = build_operational_questions(governance_portfolio)
|
|
line_budget = build_round_line_budget(ecosystem_root, project_root)
|
|
rulebook_report = evaluate_rulebook(platform_reports)
|
|
mcp_contract_report = build_mcp_contract_report(rulebook_report)
|
|
mesh_report, mesh_records = run_repository_mesh(
|
|
ecosystem_root=ecosystem_root,
|
|
project_root=project_root,
|
|
central_platform_folder=central_platform_folder,
|
|
fetch=False,
|
|
plugin_auth_attempt=push_status or "",
|
|
)
|
|
mesh_plan, mesh_reconciliation_records = apply_reconciliation_to_report(
|
|
mesh_report,
|
|
project_root,
|
|
central_platform_folder=central_platform_folder,
|
|
)
|
|
mesh_lock = acquire_lock(project_root / "dados" / "repository-mesh.lock.json", owner="mais_humana.generate")
|
|
mesh_cycle = build_runtime_cycle(mesh_report, mesh_plan, lock=mesh_lock, execute=False)
|
|
mesh_scheduler_specs = (
|
|
windows_scheduler_spec(
|
|
python_exe="C:\\Users\\Ami\\.cache\\codex-runtimes\\codex-primary-runtime\\dependencies\\python\\python.exe",
|
|
project_root=project_root,
|
|
ecosystem_root=ecosystem_root,
|
|
central_platform_folder=central_platform_folder,
|
|
),
|
|
cron_scheduler_spec(
|
|
python_exe="python",
|
|
project_root=project_root,
|
|
ecosystem_root=ecosystem_root,
|
|
central_platform_folder=central_platform_folder,
|
|
),
|
|
)
|
|
mesh_runtime_records = write_runtime_artifacts(
|
|
mesh_cycle,
|
|
mesh_scheduler_specs,
|
|
project_root,
|
|
central_platform_folder=central_platform_folder,
|
|
)
|
|
mesh_semantic_records = ()
|
|
if central_platform_folder is not None:
|
|
mesh_semantic_counts = write_repository_mesh_semantic_state(
|
|
central_platform_folder / "controle-semantico.sqlite",
|
|
report=mesh_report,
|
|
plan=mesh_plan,
|
|
cycle=mesh_cycle,
|
|
schedulers=mesh_scheduler_specs,
|
|
)
|
|
mesh_semantic_records = semantic_generated_records(central_platform_folder / "controle-semantico.sqlite")
|
|
else:
|
|
from .repository_mesh_semantic import table_counts
|
|
|
|
mesh_semantic_counts = table_counts(project_root / "controle-semantico.sqlite")
|
|
mesh_readiness = build_mesh_readiness_report(
|
|
mesh_report,
|
|
mesh_plan,
|
|
mesh_cycle,
|
|
mesh_scheduler_specs,
|
|
mesh_semantic_counts,
|
|
)
|
|
mesh_readiness_records = write_readiness_artifacts(
|
|
mesh_readiness,
|
|
project_root,
|
|
central_platform_folder=central_platform_folder,
|
|
)
|
|
mesh_gitea_plan = build_gitea_mesh_plan(mesh_report)
|
|
mesh_gitea_records = write_gitea_plan_artifacts(
|
|
mesh_gitea_plan,
|
|
project_root,
|
|
central_platform_folder=central_platform_folder,
|
|
)
|
|
release_lock(mesh_lock)
|
|
lifecycle_package = (
|
|
build_round_execution_package(
|
|
central_platform_folder,
|
|
governance_portfolio,
|
|
round_dossier=round_dossier,
|
|
total_code_lines_analyzed=line_budget.total_technical_lines,
|
|
code_lines_available=line_budget.repositories[0].code_lines if line_budget.repositories else 0,
|
|
)
|
|
if central_platform_folder is not None
|
|
else None
|
|
)
|
|
evidence_graph = build_evidence_graph(
|
|
governance_portfolio,
|
|
readiness_registry,
|
|
workflow_portfolio,
|
|
compiled_orders=governance_orders,
|
|
mcp_contract_report=mcp_contract_report,
|
|
)
|
|
generated.extend(mesh_records)
|
|
generated.extend(mesh_reconciliation_records)
|
|
generated.extend(mesh_runtime_records)
|
|
generated.extend(mesh_semantic_records)
|
|
generated.extend(mesh_readiness_records)
|
|
generated.extend(mesh_gitea_records)
|
|
|
|
profile_catalog = write_profile_catalog(project_root)
|
|
generated.append(generated_file(profile_catalog, project_root, "Catalogo de perfis humanos considerado pela matriz.", "catalogo de perfis", "json", relation_to_order))
|
|
platform_catalog = write_platform_catalog(project_root)
|
|
generated.append(generated_file(platform_catalog, project_root, "Catalogo canonico das plataformas avaliadas.", "catalogo de plataformas", "json", relation_to_order))
|
|
paradigm = write_paradigm(project_root)
|
|
generated.append(generated_file(paradigm, project_root, "Paradigma institucional da plataforma Mais Humana.", "paradigma", "markdown", relation_to_order))
|
|
|
|
data_path = write_json(project_root / "dados" / "snapshot-ecossistema.json", ecosystem_report)
|
|
generated.append(generated_file(data_path, project_root, "Snapshot JSON do ecossistema humano.", "dados auditaveis", "json", relation_to_order))
|
|
evidence_json = write_json(project_root / "dados" / "indice-evidencias.json", evidence_records)
|
|
generated.append(generated_file(evidence_json, project_root, "Indice JSON de evidencias coletadas.", "indice de evidencias", "json", relation_to_order))
|
|
evidence_md = project_root / "ecossistema" / "INDICE-DE-EVIDENCIAS-HUMANAS.md"
|
|
evidence_md.write_text(evidence_markdown(evidence_records), encoding="utf-8")
|
|
generated.append(generated_file(evidence_md, project_root, "Indice Markdown de evidencias humanas.", "indice de evidencias", "markdown", relation_to_order))
|
|
matrix_csv = write_matrix_csv(project_root / "matrizes" / "matriz-plataforma-perfil.csv", matrix_table(cells))
|
|
generated.append(generated_file(matrix_csv, project_root, "Matriz plataforma x perfil em CSV.", "matriz tabular", "csv", relation_to_order))
|
|
dossier_json = write_json(project_root / "dados" / "dossie-operacional-humano.json", round_dossier)
|
|
generated.append(generated_file(dossier_json, project_root, "Dossie operacional humano da rodada em JSON.", "dossie operacional", "json", relation_to_order))
|
|
dossier_md = project_root / "ecossistema" / "DOSSIE-OPERACIONAL-HUMANO.md"
|
|
dossier_md.write_text(dossier_to_markdown(round_dossier), encoding="utf-8")
|
|
generated.append(generated_file(dossier_md, project_root, "Dossie operacional humano da rodada em Markdown.", "dossie operacional", "markdown", relation_to_order))
|
|
justifications_md = project_root / "ecossistema" / "JUSTIFICATIVA-ORDENS-DE-SERVICO.md"
|
|
justifications_md.write_text(order_justifications_markdown(round_dossier), encoding="utf-8")
|
|
generated.append(generated_file(justifications_md, project_root, "Justificativa das ordens de servico por evidencia e gate.", "justificativa de ordens", "markdown", relation_to_order))
|
|
dossier_csv = project_root / "matrizes" / "dossie-operacional-humano.csv"
|
|
dossier_csv.write_text(write_csv_lines(dossier_compact_rows(round_dossier)), encoding="utf-8")
|
|
generated.append(generated_file(dossier_csv, project_root, "Resumo tabular do dossie operacional humano.", "dossie operacional", "csv", relation_to_order))
|
|
|
|
ecosystem_md = project_root / "ecossistema" / "RELATORIO-GERAL-DO-ECOSSISTEMA-humana.md"
|
|
ecosystem_md.write_text(ecosystem_markdown(platform_reports), encoding="utf-8")
|
|
generated.append(generated_file(ecosystem_md, project_root, "Relatorio geral em Markdown.", "relatorio geral", "markdown", relation_to_order))
|
|
ecosystem_docx = write_ecosystem_docx(project_root / "relatorios-docx" / "RELATORIO-GERAL-DO-ECOSSISTEMA-humana.docx", platform_reports)
|
|
generated.append(generated_file(ecosystem_docx, project_root, "Relatorio geral em DOCX.", "relatorio docx", "docx", relation_to_order))
|
|
|
|
heatmap = matrix_heatmap_svg(project_root / "graficos" / "matriz-plataforma-perfil.svg", cells)
|
|
generated.append(generated_file(heatmap, project_root, "Heatmap SVG da matriz plataforma x perfil.", "grafico", "svg", relation_to_order))
|
|
bars = platform_bar_svg(project_root / "graficos" / "maturidade-por-plataforma.svg", platform_reports)
|
|
generated.append(generated_file(bars, project_root, "Grafico SVG de maturidade por plataforma.", "grafico", "svg", relation_to_order))
|
|
quality_md = project_root / "ecossistema" / "QUALITY-GATE-MAIS-HUMANO.md"
|
|
quality_md.write_text(quality_to_markdown(quality_reports), encoding="utf-8")
|
|
generated.append(generated_file(quality_md, project_root, "Quality gate humano por plataforma.", "quality gate", "markdown", relation_to_order))
|
|
insights_md = project_root / "ecossistema" / "INSIGHTS-OPERACIONAIS-MAIS-HUMANA.md"
|
|
insights_md.write_text(insights_markdown(insights), encoding="utf-8")
|
|
generated.append(generated_file(insights_md, project_root, "Insights de risco, dependencias, roadmap e cobertura.", "insights", "markdown", relation_to_order))
|
|
dot_path = project_root / "graficos" / "dependencias-humanas.dot"
|
|
dot_path.write_text(dependency_dot(insights), encoding="utf-8")
|
|
generated.append(generated_file(dot_path, project_root, "Grafo DOT de dependencias humanas entre plataformas.", "grafo", "dot", relation_to_order))
|
|
questions_md = project_root / "pessoas-e-papeis" / "perguntas-humanas-respondidas.md"
|
|
questions_md.write_text(questions_markdown(human_questions), encoding="utf-8")
|
|
generated.append(generated_file(questions_md, project_root, "Perguntas humanas respondidas por plataforma e perfil.", "perguntas humanas", "markdown", relation_to_order))
|
|
playbooks_md = project_root / "pessoas-e-papeis" / "playbooks-humanos.md"
|
|
playbooks_md.write_text(playbooks_markdown(playbooks), encoding="utf-8")
|
|
generated.append(generated_file(playbooks_md, project_root, "Playbooks humanos por perfil operacional.", "playbooks", "markdown", relation_to_order))
|
|
commands_md = project_root / "ecossistema" / "COMANDOS-HUMANOS-EQUIVALENTES.md"
|
|
commands_md.write_text(commands_markdown(command_specs), encoding="utf-8")
|
|
generated.append(generated_file(commands_md, project_root, "Comandos humanos equivalentes para validacao.", "comandos", "markdown", relation_to_order))
|
|
|
|
for report in platform_reports:
|
|
md_path = project_root / "plataformas" / f"{report.platform.platform_id}.md"
|
|
md_path.write_text(platform_markdown(report), encoding="utf-8")
|
|
generated.append(generated_file(md_path, project_root, f"Relatorio humano Markdown da plataforma {report.platform.platform_id}.", "relatorio por plataforma", "markdown", relation_to_order))
|
|
docx_path = write_platform_docx(project_root / "relatorios-docx" / "plataformas" / f"{report.platform.platform_id}.docx", report)
|
|
generated.append(generated_file(docx_path, project_root, f"Relatorio humano DOCX da plataforma {report.platform.platform_id}.", "relatorio docx por plataforma", "docx", relation_to_order))
|
|
radar = profile_radar_svg(project_root / "graficos" / f"radar-{report.platform.platform_id}.svg", report)
|
|
generated.append(generated_file(radar, project_root, f"Radar SVG humano da plataforma {report.platform.platform_id}.", "grafico radar", "svg", relation_to_order))
|
|
|
|
goals = write_human_goals(project_root, platform_reports)
|
|
generated.append(generated_file(goals, project_root, "Metas humanas por plataforma.", "metas humanas", "markdown", relation_to_order))
|
|
screen_map = write_screen_report_map(project_root, platform_reports)
|
|
generated.append(generated_file(screen_map, project_root, "Mapa de telas e relatorios esperados.", "mapa de superficie", "markdown", relation_to_order))
|
|
|
|
order_summary = project_root / "os-orientadoras" / "ordens-de-saida.json"
|
|
write_json(order_summary, exit_orders)
|
|
generated.append(generated_file(order_summary, project_root, "Ordens de saida em JSON.", "ordens orientadoras", "json", relation_to_order))
|
|
quality_json = write_json(project_root / "dados" / "quality-gates.json", quality_reports)
|
|
generated.append(generated_file(quality_json, project_root, "Quality gates em JSON.", "quality gates", "json", relation_to_order))
|
|
questions_json = write_json(project_root / "dados" / "perguntas-humanas.json", human_questions)
|
|
generated.append(generated_file(questions_json, project_root, "Perguntas humanas em JSON.", "perguntas humanas", "json", relation_to_order))
|
|
playbooks_json = write_json(project_root / "dados" / "playbooks-humanos.json", playbooks)
|
|
generated.append(generated_file(playbooks_json, project_root, "Playbooks humanos em JSON.", "playbooks", "json", relation_to_order))
|
|
commands_json = write_json(project_root / "dados" / "comandos-humanos-equivalentes.json", command_specs)
|
|
generated.append(generated_file(commands_json, project_root, "Comandos humanos equivalentes em JSON.", "comandos", "json", relation_to_order))
|
|
insights_json = write_json(project_root / "dados" / "insights-operacionais.json", insights)
|
|
generated.append(generated_file(insights_json, project_root, "Insights operacionais em JSON.", "insights", "json", relation_to_order))
|
|
index_html = write_index_html(project_root / "ecossistema" / "index.html", platform_reports, quality_reports)
|
|
generated.append(generated_file(index_html, project_root, "Indice HTML local para revisao dos relatorios humanos.", "html operacional", "html", relation_to_order))
|
|
|
|
governance_export_bundle = write_governance_exports(
|
|
project_root,
|
|
governance_exports(
|
|
project_root,
|
|
governance_portfolio,
|
|
readiness_registry,
|
|
workflow_portfolio,
|
|
scenario_portfolio,
|
|
evidence_graph,
|
|
governance_questions,
|
|
budget=line_budget,
|
|
compiled_orders=governance_orders,
|
|
lifecycle=lifecycle_package,
|
|
),
|
|
relation_to_order,
|
|
)
|
|
generated.extend(governance_export_bundle.generated_records)
|
|
rulebook_json = write_json(project_root / "dados" / "rulebook-humano-operacional.json", rulebook_report)
|
|
generated.append(generated_file(rulebook_json, project_root, "Rulebook humano-operacional completo em JSON.", "rulebook humano", "json", relation_to_order))
|
|
rulebook_compact = write_json(project_root / "dados" / "rulebook-humano-operacional-compacto.json", rulebook_compact_json(rulebook_report))
|
|
generated.append(generated_file(rulebook_compact, project_root, "Rulebook humano-operacional compacto para MCP/UI.", "rulebook compacto", "json", relation_to_order))
|
|
rulebook_md = project_root / "ecossistema" / "RULEBOOK-HUMANO-OPERACIONAL.md"
|
|
rulebook_md.write_text(rulebook_markdown(rulebook_report), encoding="utf-8")
|
|
generated.append(generated_file(rulebook_md, project_root, "Relatorio Markdown do rulebook humano-operacional.", "rulebook humano", "markdown", relation_to_order))
|
|
rulebook_matrix = project_root / "matrizes" / "rulebook-humano-operacional.csv"
|
|
rulebook_matrix.write_text(rulebook_csv(rulebook_report), encoding="utf-8")
|
|
generated.append(generated_file(rulebook_matrix, project_root, "Matriz CSV de cobertura do rulebook.", "matriz rulebook", "csv", relation_to_order))
|
|
mcp_contract_json = write_json(project_root / "dados" / "mcp-contratos-humanos.json", mcp_contract_report)
|
|
generated.append(generated_file(mcp_contract_json, project_root, "Relatorio completo de contratos MCP humanos.", "mcp contratos", "json", relation_to_order))
|
|
mcp_provider_json = write_json(project_root / "dados" / "mcp-provider-mais-humana.json", mcp_provider_payload(mcp_contract_report))
|
|
generated.append(generated_file(mcp_provider_json, project_root, "Envelope MCP minimo da Mais Humana.", "mcp provider", "json", relation_to_order))
|
|
mcp_provider_compact = write_json(project_root / "dados" / "mcp-provider-mais-humana-compacto.json", mcp_provider_compact_json(mcp_contract_report))
|
|
generated.append(generated_file(mcp_provider_compact, project_root, "Contrato MCP compacto da Mais Humana.", "mcp provider compacto", "json", relation_to_order))
|
|
mcp_same_source = write_json(project_root / "dados" / "mcp-admin-ui-same-source-validation.json", same_source_validation_payload(mcp_contract_report))
|
|
generated.append(generated_file(mcp_same_source, project_root, "Validacao same-source GPT/UI baseada no contrato MCP.", "mcp same-source", "json", relation_to_order))
|
|
mcp_contract_md = project_root / "ecossistema" / "MCP-PROVIDER-MAIS-HUMANA.md"
|
|
mcp_contract_md.write_text(mcp_contract_markdown(mcp_contract_report), encoding="utf-8")
|
|
generated.append(generated_file(mcp_contract_md, project_root, "Relatorio Markdown do provider MCP Mais Humana.", "mcp provider", "markdown", relation_to_order))
|
|
report_models_md = project_root / "ecossistema" / "MODELOS-OFICIAIS-RELATORIO-HUMANO.md"
|
|
report_models_md.write_text(official_report_models_markdown(mcp_contract_report), encoding="utf-8")
|
|
generated.append(generated_file(report_models_md, project_root, "Catalogo de modelos oficiais de relatorio humano.", "modelos relatorio", "markdown", relation_to_order))
|
|
ui_policy_md = project_root / "ecossistema" / "UI-RENDERER-SAME-SOURCE-POLICY.md"
|
|
ui_policy_md.write_text(ui_renderer_policy_markdown(mcp_contract_report), encoding="utf-8")
|
|
generated.append(generated_file(ui_policy_md, project_root, "Politica UI como renderizador sem fonte paralela.", "politica ui", "markdown", relation_to_order))
|
|
mcp_contract_csv_path = project_root / "matrizes" / "mcp-contratos-humanos.csv"
|
|
mcp_contract_csv_path.write_text(mcp_contract_csv(mcp_contract_report), encoding="utf-8")
|
|
generated.append(generated_file(mcp_contract_csv_path, project_root, "Matriz CSV dos contratos MCP humanos.", "matriz mcp", "csv", relation_to_order))
|
|
governance_snapshot_path = project_root / "dados" / "snapshot-governanca-atual.json"
|
|
previous_governance_snapshot = load_governance_snapshot(governance_snapshot_path)
|
|
current_governance_snapshot = snapshot_from_portfolio(governance_portfolio)
|
|
write_governance_snapshot(governance_snapshot_path, current_governance_snapshot)
|
|
generated.append(generated_file(governance_snapshot_path, project_root, "Snapshot compacto de governanca operacional.", "snapshot governanca", "json", relation_to_order))
|
|
governance_delta_path = project_root / "ecossistema" / "DELTA-GOVERNANCA-OPERACIONAL.md"
|
|
governance_delta_path.write_text(
|
|
governance_delta_markdown(diff_governance_snapshots(previous_governance_snapshot, current_governance_snapshot)),
|
|
encoding="utf-8",
|
|
)
|
|
generated.append(generated_file(governance_delta_path, project_root, "Delta de governanca operacional.", "delta governanca", "markdown", relation_to_order))
|
|
governance_delta_csv = project_root / "matrizes" / "delta-governanca-operacional.csv"
|
|
governance_delta_csv.write_text(
|
|
rows_to_csv(governance_delta_rows(diff_governance_snapshots(previous_governance_snapshot, current_governance_snapshot))),
|
|
encoding="utf-8",
|
|
)
|
|
generated.append(generated_file(governance_delta_csv, project_root, "Delta de governanca operacional em CSV.", "delta governanca", "csv", relation_to_order))
|
|
|
|
if central_platform_folder is not None:
|
|
written_orders = write_orders(exit_orders, central_platform_folder)
|
|
write_json(order_summary, exit_orders)
|
|
for path in written_orders:
|
|
generated.append(generated_file(path, project_root, "Ordem de saida criada na central.", "ordem de servico", "markdown", relation_to_order))
|
|
reports_dir = central_platform_folder / "reports"
|
|
reports_dir.mkdir(parents=True, exist_ok=True)
|
|
executed = reports_dir / "EXECUTADO__fundacao-tudo-para-ia-mais-humana.md"
|
|
executed.write_text(executed_order_markdown(platform_reports, exit_orders), encoding="utf-8")
|
|
generated.append(generated_file(executed, project_root, "Registro EXECUTADO da rodada.", "registro de execucao", "markdown", relation_to_order))
|
|
pending = reports_dir / "PENDENCIAS-CODEX__fundacao-tudo-para-ia-mais-humana.md"
|
|
pending.write_text(pending_markdown(platform_reports, push_status=push_status), encoding="utf-8")
|
|
generated.append(generated_file(pending, project_root, "Registro de pendencias reais da rodada.", "pendencias", "markdown", relation_to_order))
|
|
audit_dir = central_platform_folder / "audit"
|
|
audit_dir.mkdir(parents=True, exist_ok=True)
|
|
audit = audit_dir / "AUDITORIA-GPT__fundacao-tudo-para-ia-mais-humana.md"
|
|
audit.write_text(audit_markdown(platform_reports, exit_orders), encoding="utf-8")
|
|
generated.append(generated_file(audit, project_root, "Auditoria da rodada.", "auditoria", "markdown", relation_to_order))
|
|
operational_executed = reports_dir / "EXECUTADO__rodada-operacional-mais-humana.md"
|
|
operational_executed.write_text(dossier_to_markdown(round_dossier), encoding="utf-8")
|
|
generated.append(generated_file(operational_executed, project_root, "Registro EXECUTADO operacional com dossie humano.", "registro de execucao", "markdown", relation_to_order))
|
|
operational_pending = reports_dir / "PENDENCIAS-CODEX__rodada-operacional-mais-humana.md"
|
|
operational_pending.write_text("\n".join(["# Pendencias operacionais consolidadas", ""] + [f"- {item}" for item in round_dossier.pending_items]) + "\n", encoding="utf-8")
|
|
generated.append(generated_file(operational_pending, project_root, "Pendencias consolidadas do dossie operacional.", "pendencias", "markdown", relation_to_order))
|
|
operational_audit = audit_dir / "AUDITORIA-GPT__rodada-operacional-mais-humana.md"
|
|
operational_audit.write_text(order_justifications_markdown(round_dossier), encoding="utf-8")
|
|
generated.append(generated_file(operational_audit, project_root, "Auditoria operacional das ordens tratadas.", "auditoria", "markdown", relation_to_order))
|
|
sqlite_path = central_platform_folder / "controle-semantico.sqlite"
|
|
write_semantic_state(sqlite_path, tuple(generated), exit_orders, platform_reports, recommendations, round_dossier)
|
|
|
|
provisional_bundle = ReportBundle(
|
|
output_root=str(project_root),
|
|
generated_files=tuple(generated),
|
|
platform_count=len(platform_reports),
|
|
profile_count=len(HUMAN_PROFILES),
|
|
matrix_cells=len(cells),
|
|
total_code_lines_analyzed=ecosystem_report.total_code_lines,
|
|
warnings=tuple(warning for report in platform_reports for warning in report.scan.warnings),
|
|
)
|
|
acceptance = build_acceptance_report(project_root, platform_reports, exit_orders, provisional_bundle)
|
|
acceptance_path = project_root / "ecossistema" / "ACCEPTANCE-CHECKLIST-MAIS-HUMANA.md"
|
|
acceptance_path.write_text(acceptance_markdown(acceptance), encoding="utf-8")
|
|
generated.append(generated_file(acceptance_path, project_root, "Checklist de aceite da rodada.", "acceptance", "markdown", relation_to_order))
|
|
redaction = scan_generated_artifacts(project_root)
|
|
redaction_path = project_root / "ecossistema" / "REDACTION-CHECK-MAIS-HUMANA.md"
|
|
redaction_path.write_text(redaction_markdown(redaction), encoding="utf-8")
|
|
generated.append(generated_file(redaction_path, project_root, "Checagem textual de vazamento de segredos.", "redaction", "markdown", relation_to_order))
|
|
snapshot_path = project_root / "dados" / "snapshot-score-atual.json"
|
|
previous_snapshot = load_snapshot(snapshot_path)
|
|
current_snapshot = snapshot_from_reports(platform_reports)
|
|
write_snapshot(snapshot_path, current_snapshot)
|
|
generated.append(generated_file(snapshot_path, project_root, "Snapshot compacto de score por plataforma.", "snapshot", "json", relation_to_order))
|
|
delta_path = project_root / "ecossistema" / "DELTA-MATURIDADE-HUMANA.md"
|
|
delta_path.write_text(snapshot_delta_markdown(diff_snapshots(previous_snapshot, current_snapshot)), encoding="utf-8")
|
|
generated.append(generated_file(delta_path, project_root, "Delta de maturidade humana contra snapshot anterior.", "delta", "markdown", relation_to_order))
|
|
|
|
if central_platform_folder is not None:
|
|
central_bundle = ReportBundle(
|
|
output_root=str(project_root),
|
|
generated_files=tuple(generated),
|
|
platform_count=len(platform_reports),
|
|
profile_count=len(HUMAN_PROFILES),
|
|
matrix_cells=len(cells),
|
|
total_code_lines_analyzed=ecosystem_report.total_code_lines,
|
|
warnings=tuple(warning for report in platform_reports for warning in report.scan.warnings),
|
|
)
|
|
for path in write_central_status_pages(central_platform_folder, central_bundle, platform_reports, exit_orders):
|
|
generated.append(generated_file(path, project_root, "Pagina de estado/indice da central.", "estado central", "markdown", relation_to_order))
|
|
sqlite_path = central_platform_folder / "controle-semantico.sqlite"
|
|
write_semantic_state(sqlite_path, tuple(generated), exit_orders, platform_reports, recommendations, round_dossier)
|
|
|
|
final_bundle = ReportBundle(
|
|
output_root=str(project_root),
|
|
generated_files=tuple(generated),
|
|
platform_count=len(platform_reports),
|
|
profile_count=len(HUMAN_PROFILES),
|
|
matrix_cells=len(cells),
|
|
total_code_lines_analyzed=ecosystem_report.total_code_lines,
|
|
warnings=tuple(warning for report in platform_reports for warning in report.scan.warnings),
|
|
)
|
|
assurance = build_assurance_suite(
|
|
project_root=project_root,
|
|
bundle=final_bundle,
|
|
platform_reports=platform_reports,
|
|
portfolio=governance_portfolio,
|
|
lifecycle_package=lifecycle_package,
|
|
compiled_orders=governance_orders,
|
|
central_folder=central_platform_folder,
|
|
extra_text=(push_status or "",),
|
|
)
|
|
assurance_json = write_json(project_root / "dados" / "assurance-rodada.json", assurance)
|
|
generated.append(generated_file(assurance_json, project_root, "Assurance da rodada em JSON.", "assurance", "json", relation_to_order))
|
|
assurance_md = project_root / "ecossistema" / "ASSURANCE-RODADA-MAIS-HUMANA.md"
|
|
assurance_md.write_text(assurance_markdown(assurance), encoding="utf-8")
|
|
generated.append(generated_file(assurance_md, project_root, "Assurance da rodada em Markdown.", "assurance", "markdown", relation_to_order))
|
|
assurance_csv = project_root / "matrizes" / "assurance-rodada.csv"
|
|
assurance_csv.write_text(rows_to_csv(assurance_rows(assurance)), encoding="utf-8")
|
|
generated.append(generated_file(assurance_csv, project_root, "Assurance da rodada em CSV.", "assurance", "csv", relation_to_order))
|
|
if central_platform_folder is not None and lifecycle_package is not None:
|
|
for path in write_central_lifecycle_exports(central_platform_folder, lifecycle_package):
|
|
generated.append(generated_file(path, project_root, "Fechamento lifecycle das ordens ativas na central.", "lifecycle central", "markdown", relation_to_order))
|
|
reconciled = build_reconciled_status(
|
|
governance_portfolio,
|
|
readiness_registry,
|
|
workflow_portfolio,
|
|
scenario_portfolio,
|
|
lifecycle=lifecycle_package,
|
|
budget=line_budget,
|
|
assurance=assurance,
|
|
)
|
|
for path in write_reconciled_status(central_platform_folder, reconciled):
|
|
generated.append(generated_file(path, project_root, "Estado reconciliado da central.", "estado reconciliado", "markdown", relation_to_order))
|
|
write_governance_semantic_state(
|
|
central_platform_folder / "controle-semantico.sqlite",
|
|
governance_portfolio,
|
|
readiness_registry,
|
|
workflow_portfolio,
|
|
scenario_portfolio,
|
|
assurance=assurance,
|
|
lifecycle=lifecycle_package,
|
|
budget=line_budget,
|
|
mcp_contract_report=mcp_contract_report,
|
|
)
|
|
final_bundle = ReportBundle(
|
|
output_root=str(project_root),
|
|
generated_files=tuple(generated),
|
|
platform_count=len(platform_reports),
|
|
profile_count=len(HUMAN_PROFILES),
|
|
matrix_cells=len(cells),
|
|
total_code_lines_analyzed=ecosystem_report.total_code_lines,
|
|
warnings=tuple(warning for report in platform_reports for warning in report.scan.warnings),
|
|
)
|
|
contract = build_contract(final_bundle, platform_reports)
|
|
contract_json = write_json(project_root / "dados" / "contrato-publico-mais-humana.json", contract)
|
|
generated.append(generated_file(contract_json, project_root, "Contrato publico JSON da plataforma Mais Humana.", "contrato", "json", relation_to_order))
|
|
contract_md = project_root / "ecossistema" / "CONTRATO-PUBLICO-MAIS-HUMANA.md"
|
|
contract_md.write_text(contract_markdown(contract), encoding="utf-8")
|
|
generated.append(generated_file(contract_md, project_root, "Contrato publico Markdown da plataforma Mais Humana.", "contrato", "markdown", relation_to_order))
|
|
|
|
if central_platform_folder is not None:
|
|
sqlite_path = central_platform_folder / "controle-semantico.sqlite"
|
|
write_semantic_state(sqlite_path, tuple(generated), exit_orders, platform_reports, recommendations, round_dossier)
|
|
|
|
return ReportBundle(
|
|
output_root=str(project_root),
|
|
generated_files=tuple(generated),
|
|
platform_count=len(platform_reports),
|
|
profile_count=len(HUMAN_PROFILES),
|
|
matrix_cells=len(cells),
|
|
total_code_lines_analyzed=ecosystem_report.total_code_lines,
|
|
warnings=tuple(warning for report in platform_reports for warning in report.scan.warnings),
|
|
)
|