docs-cli 0.1.0__py3-none-any.whl

generate_embeddings.py

@@ -0,0 +1,237 @@
+# generate_embeddings.py (Atualizado para lidar com a estrutura e com Rate Limiting e incluir slug)
+
+import json
+import os
+import google.generativeai as genai
+from dotenv import load_dotenv
+import time
+import re
+
+# Carrega as variáveis de ambiente do arquivo .env
+load_dotenv()
+
+# --- Configuração da API do Google Gemini ---
+GOOGLE_API_KEY = os.getenv("GOOGLE_API_KEY")
+if not GOOGLE_API_KEY:
+    raise ValueError("A variável de ambiente GOOGLE_API_KEY não está configurada.")
+genai.configure(api_key=GOOGLE_API_KEY) # type: ignore
+EMBEDDING_MODEL = "models/embedding-001"
+
+# Limite de caracteres para o embedding, para evitar exceder o limite de tokens da API
+EMBEDDING_TEXT_MAX_LENGTH = 1024 
+
+# --- Variáveis para controle de Rate Limiting ---
+REQUEST_LIMIT_PER_MINUTE = 150
+request_count = 0
+last_request_time = time.time() # Inicializa com o tempo atual
+
+def clean_text_for_embedding(text):
+    """
+    Remove caracteres especiais e formatação markdown para texto que será EMBEDDADO.
+    Esta função foi aprimorada para lidar com mais casos de Markdown.
+    """
+    # Remove links markdown (e.g., [texto](link))
+    text = re.sub(r'\[.*?\]\(.*?\)', '', text)
+    # Remove bold/italic (**, __, *, _)
+    text = re.sub(r'\*\*|__|\*|_', '', text)
+    # Remove cabeçalhos (#, ##, ### etc.)
+    text = re.sub(r'#+\s*', '', text)
+    # Remove blocos de código (``` ou `)
+    text = re.sub(r'```.*?```', '', text, flags=re.DOTALL) # Para blocos multilinhas
+    text = re.sub(r'`[^`]*`', '', text) # Para blocos de uma linha
+    # Remove blockquotes (>)
+    text = re.sub(r'^\s*>\s*', '', text, flags=re.MULTILINE)
+    # Remove linhas de lista (- + *)
+    text = re.sub(r'^\s*[-+*]\s*', '', text, flags=re.MULTILINE)
+    # Remove linhas horizontais (---, ***, ___)
+    text = re.sub(r'^-{3,}|^\*{3,}|^__{3,}', '', text, flags=re.MULTILINE)
+    # Remove múltiplos espaços e quebras de linha para um único espaço
+    text = re.sub(r'\s+', ' ', text).strip() 
+    # Substitui múltiplas quebras de linha por um único espaço (se houver alguma que restou)
+    text = re.sub(r'\n+', ' ', text).strip() 
+    return text
+
+def split_content_into_semantic_chunks(document_content, doc_title, filepath, doc_slug): # MODIFICADO: adicionado doc_slug
+    """
+    Divide o conteúdo de um único documento Markdown em chunks baseados em cabeçalhos (H2, H3, etc.).
+    Ignora seções de metadados se ainda estiverem presentes.
+    Inclui o slug do documento em cada chunk.
+    """
+    chunks = []
+    
+    # Remove o bloco de metadados se por acaso ainda estiver aqui
+    content_without_metadata = re.sub(r'## Metadata_Start.*?## Metadata_End', '', document_content, flags=re.DOTALL).strip()
+    
+    # Divide por qualquer cabeçalho de nível 2 ou superior (##, ###, etc.)
+    sections = re.split(r'(^##+\s*.*$)', content_without_metadata, flags=re.MULTILINE)
+
+    current_chunk_title = doc_title 
+    current_chunk_content_lines = []
+
+    for i, part in enumerate(sections):
+        if not part.strip(): 
+            continue
+
+        if part.startswith("##"): 
+            if current_chunk_content_lines:
+                chunks.append({
+                    "document_title": doc_title,
+                    "document_filepath": filepath,
+                    "document_slug": doc_slug, # MODIFICADO: adicionado slug
+                    "chunk_title": current_chunk_title.strip(),
+                    "chunk_content": "\n".join(current_chunk_content_lines).strip()
+                })
+                current_chunk_content_lines = [] 
+            
+            current_chunk_title = part.strip().lstrip('# ').strip() 
+        else: 
+            current_chunk_content_lines.append(part.strip())
+
+    if current_chunk_content_lines:
+        chunks.append({
+            "document_title": doc_title,
+            "document_filepath": filepath,
+            "document_slug": doc_slug, # MODIFICADO: adicionado slug
+            "chunk_title": current_chunk_title.strip(),
+            "chunk_content": "\n".join(current_chunk_content_lines).strip()
+        })
+    
+    if not chunks and content_without_metadata.strip():
+        chunks.append({
+            "document_title": doc_title,
+            "document_filepath": filepath,
+            "document_slug": doc_slug, # MODIFICADO: adicionado slug
+            "chunk_title": doc_title, # Usa o título do documento se não houver seções
+            "chunk_content": content_without_metadata.strip()
+        })
+    
+    return [chunk for chunk in chunks if chunk['chunk_content'].strip()]
+
+
+def generate_embedding_with_retry(text_content):
+    """
+    Gera um embedding para o conteúdo de texto, com mecanismo de retry e rate limiting.
+    """
+    global request_count, last_request_time
+
+    current_time = time.time()
+    elapsed_time = current_time - last_request_time
+
+    if elapsed_time < 60 and request_count >= REQUEST_LIMIT_PER_MINUTE:
+        sleep_duration = 60 - elapsed_time
+        print(f"  Atingido limite de requisições por minuto. Aguardando {sleep_duration:.2f} segundos...")
+        time.sleep(sleep_duration)
+        request_count = 0
+        last_request_time = time.time()
+    elif elapsed_time >= 60: 
+        request_count = 0
+        last_request_time = time.time()
+    
+    request_count += 1
+    
+    retries = 3
+    for attempt in range(retries):
+        try:
+            response = genai.embed_content(model=EMBEDDING_MODEL, content=[text_content]) # type: ignore
+            return response['embedding'][0] 
+        except Exception as e:
+            print(f"Erro ao gerar embedding (tentativa {attempt+1}/{retries}): {e}")
+            if attempt < retries - 1:
+                time.sleep(2 ** attempt) 
+            else:
+                return None 
+    return None
+
+def generate_embeddings_for_docs(input_json_path="raw_docs.json", output_json_path="embeddings.json"):
+    """
+    Lê o JSON com dados de documentos (já separados), divide cada um em chunks,
+    gera embeddings para cada chunk, e salva o resultado final em um novo JSON.
+    """
+    if not os.path.exists(input_json_path):
+        print(f"Erro: O arquivo '{input_json_path}' não foi encontrado. Por favor, execute o script de extração (ex: 'extract_consolidated_md_to_raw_json.py') primeiro.")
+        return False
+
+    print(f"Gerando embeddings para documentos de '{input_json_path}'...")
+
+    try:
+        with open(input_json_path, 'r', encoding='utf-8') as f:
+            raw_docs = json.load(f)
+    except json.JSONDecodeError as e:
+        print(f"Erro ao decodificar JSON de '{input_json_path}': {e}")
+        return False
+    except Exception as e:
+        print(f"Erro inesperado ao carregar '{input_json_path}': {e}")
+        return False
+
+    all_processed_chunks = [] 
+    total_raw_docs = len(raw_docs)
+    
+    for i, doc_data in enumerate(raw_docs):
+        doc_title = doc_data.get("title", "Título Desconhecido")
+        doc_content_full = doc_data.get("content", "") 
+        file_path_relative = doc_data.get("filepath", "N/A")
+        doc_slug = doc_data.get("slug", "") # MODIFICADO: Obtém o slug
+
+        print(f"\n--- Processando documento {i + 1}/{total_raw_docs}: '{doc_title}' ({file_path_relative}) ---")
+        
+        # MODIFICADO: Passa o doc_slug para a função de chunking
+        chunks_for_doc = split_content_into_semantic_chunks(doc_content_full, doc_title, file_path_relative, doc_slug) 
+        
+        if not chunks_for_doc:
+            print(f"Atenção: Nenhum chunk válido gerado para o documento '{doc_title}'. Pulando.")
+            continue 
+
+        for chunk_idx, chunk in enumerate(chunks_for_doc):
+            embedding_text_raw = f"Documento: {chunk['document_title']}. Seção: {chunk['chunk_title']}. Conteúdo: {chunk['chunk_content']}"
+            embedding_text = clean_text_for_embedding(embedding_text_raw)
+            
+            if len(embedding_text) > EMBEDDING_TEXT_MAX_LENGTH:
+                embedding_text = embedding_text[:EMBEDDING_TEXT_MAX_LENGTH]
+                print(f"  Truncando chunk {chunk_idx+1} de '{chunk['chunk_title']}' para {EMBEDDING_TEXT_MAX_LENGTH} caracteres para embedding.")
+            
+            if not embedding_text.strip():
+                print(f"  Atenção: Texto limpo para embedding vazio para chunk '{chunk['chunk_title']}' do documento '{doc_title}'. Pulando embedding.")
+                chunk["embedding"] = None
+                all_processed_chunks.append(chunk)
+                continue
+
+            print(f"  Gerando embedding para chunk {chunk_idx+1} de '{chunk['chunk_title']}'...")
+            chunk_embedding = generate_embedding_with_retry(embedding_text)
+
+            if chunk_embedding is not None:
+                chunk["embedding"] = chunk_embedding
+                all_processed_chunks.append(chunk)
+            else:
+                print(f"  Atenção: Falha ao gerar embedding para chunk '{chunk['chunk_title']}' do documento '{doc_title}'. Chunk será incluído sem embedding.")
+                chunk["embedding"] = None
+                all_processed_chunks.append(chunk)
+
+    if not all_processed_chunks:
+        print("Nenhum chunk processado com sucesso (sem embeddings ou dados de entrada).")
+        return False
+
+    try:
+        with open(output_json_path, 'w', encoding='utf-8') as f:
+            json.dump(all_processed_chunks, f, ensure_ascii=False, indent=4)
+        print(f"\nGeração de embeddings concluída. Salvou {len(all_processed_chunks)} chunks com embeddings em '{output_json_path}'.")
+        return True
+    except Exception as e:
+        print(f"Erro ao salvar o arquivo JSON: {e}")
+        return False
+
+def cli_main():
+    import argparse
+    parser = argparse.ArgumentParser(description="Gera embeddings para documentos a partir de um JSON.")
+    parser.add_argument("input_json_path", help="Caminho para o arquivo JSON de entrada (ex: raw_docs.json).")
+    parser.add_argument("output_json_path", help="Caminho para o arquivo JSON de saída dos embeddings (ex: embeddings.json).")
+    args = parser.parse_args()
+    success = generate_embeddings_for_docs(args.input_json_path, args.output_json_path)
+    if not success:
+        print("A geração de embeddings falhou.")
+        sys.exit(1) # Garante que sys está importado se for usar aqui
+    else:
+        print("Geração de embeddings concluída com sucesso.")
+
+if __name__ == "__main__":
+    import sys # Adicionado aqui para garantir que está disponível para cli_main
+    cli_main()

generate_report.py

@@ -0,0 +1,118 @@
+# generate_md_report.py
+
+import json
+import os
+from datetime import datetime
+
+def generate_md_report(evaluation_json_path="evaluation_results.json", output_md_path="coverage_report.md", top_k_chunks=5):
+    """
+    Gera um relatório Markdown a partir do JSON de avaliação.
+    """
+    if not os.path.exists(evaluation_json_path):
+        print(f"Erro: O arquivo JSON de avaliação '{evaluation_json_path}' não foi encontrado. Execute 'evaluate_coverage.py' primeiro.")
+        return False
+
+    print(f"Lendo dados de avaliação de '{evaluation_json_path}'...")
+    try:
+        with open(evaluation_json_path, 'r', encoding='utf-8') as f:
+            evaluation_results = json.load(f)
+    except json.JSONDecodeError as e:
+        print(f"Erro ao decodificar JSON de '{evaluation_json_path}': {e}")
+        return False
+    except Exception as e:
+        print(f"Erro inesperado ao carregar '{evaluation_json_path}': {e}")
+        return False
+
+    if not evaluation_results:
+        print("Atenção: Nenhum resultado de avaliação válido encontrado no JSON.")
+        return False
+
+    # Calcular resumo
+    total_questions = len(evaluation_results)
+    found_count = sum(1 for item in evaluation_results if "Encontrada" in item['status'])
+    coverage_percentage = (found_count / total_questions * 100) if total_questions > 0 else 0
+
+    report_date = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+
+    md_content = f"""# Relatório de Cobertura da Documentação
+
+**Gerado em:** {report_date}
+
+---
+
+## Resumo Geral
+
+* **Total de Perguntas Avaliadas:** {total_questions}
+* **Perguntas com Cobertura Suficiente:** {found_count}
+* **Porcentagem de Cobertura Geral:** {coverage_percentage:.2f}%
+
+---
+
+## Resultados Detalhados por Pergunta
+
+"""
+
+    for i, item in enumerate(evaluation_results):
+        md_content += f"""
+### {i + 1}. Pergunta: {item['pergunta']}
+
+* **Status:** {item['status']}
+* **Resposta Ideal:** {item['resposta_ideal']}
+
+"""
+        # Detalhes da Cobertura por Frase
+        if item.get('cobertura_detalhes'):
+            md_content += f"#### Cobertura por Frase da Resposta Ideal:\n\n"
+            for detail in item['cobertura_detalhes']:
+                status_icon = "✅" if "Coberta" in detail['status'] else "❌"
+                md_content += f"""* **{status_icon} Frase:** {detail['frase_ideal']}
+    * **Status da Frase:** {detail['status']}
+    * **Similaridade Máx. para Frase:** {detail['similaridade_max']}
+    * **Chunk Correspondente:** {detail['chunk_correspondente']}
+"""
+            md_content += "\n" # Adiciona uma linha em branco para espaçamento
+
+        # Top K Chunks Relevantes
+        md_content += f"#### Top {top_k_chunks} Chunks Relevantes para a Pergunta:\n\n"
+        if item.get('top_k_chunks_relevantes'):
+            for chunk in item['top_k_chunks_relevantes']:
+                md_content += f"""* **Documento:** {chunk['document_title']}
+    * **Seção:** {chunk['chunk_title']}
+    * **Caminho do Arquivo:** `{chunk['filepath']}`
+    * **Similaridade com a Pergunta:** {chunk['similarity_to_query']}
+    * **Conteúdo (preview):** `{chunk['content_preview'].replace('`', '\\`')}`
+"""
+            md_content += "\n" # Adiciona uma linha em branco para espaçamento
+        else:
+            md_content += "* Nenhum chunk relevante encontrado.\n\n"
+    
+    try:
+        with open(output_md_path, 'w', encoding='utf-8') as f:
+            f.write(md_content)
+        print(f"Relatório Markdown gerado com sucesso em '{output_md_path}'.")
+        return True
+    except Exception as e:
+        print(f"Erro ao salvar o relatório Markdown: {e}")
+        return False
+
+if __name__ == "__main__":
+    import argparse # Adicione
+    import sys      # Adicione
+
+    parser = argparse.ArgumentParser(description="Gera relatório Markdown da avaliação de cobertura.")
+    # Tornando-os posicionais para simplificar a chamada via subprocesso
+    parser.add_argument("evaluation_json_path", help="Caminho para o arquivo JSON de resultados da avaliação.")
+    parser.add_argument("output_md_path", help="Caminho para salvar o relatório Markdown.")
+    parser.add_argument("top_k_chunks", type=int, help="Valor de top_k_chunks usado na avaliação.")
+    args = parser.parse_args()
+
+    success = generate_md_report(
+        evaluation_json_path=args.evaluation_json_path,
+        output_md_path=args.output_md_path,
+        top_k_chunks=args.top_k_chunks
+    )
+    if not success:
+        print("A geração do relatório Markdown falhou.")
+        sys.exit(1)
+    else:
+        print("Geração do relatório Markdown concluída com sucesso.")

generate_report_html.py

@@ -0,0 +1,204 @@
+# generate_report_html.py
+
+import json
+import os
+from datetime import datetime
+import argparse # Make sure argparse is imported
+import sys      # Make sure sys is imported
+
+# ... (keep your generate_html_report function as is) ...
+def generate_html_report(evaluation_json_path="evaluation_results.json", output_html_path="coverage_report.html", top_k_chunks=5):
+    # ... (your existing code for this function)
+    if not os.path.exists(evaluation_json_path):
+        print(f"Erro: O arquivo JSON de avaliação '{evaluation_json_path}' não foi encontrado. Execute 'evaluate_coverage.py' primeiro.")
+        return False
+
+    print(f"Lendo dados de avaliação de '{evaluation_json_path}'...")
+    try:
+        with open(evaluation_json_path, 'r', encoding='utf-8') as f:
+            evaluation_results = json.load(f)
+    except json.JSONDecodeError as e:
+        print(f"Erro ao decodificar JSON de '{evaluation_json_path}': {e}")
+        return False
+    except Exception as e:
+        print(f"Erro inesperado ao carregar '{evaluation_json_path}': {e}")
+        return False
+
+    if not evaluation_results:
+        print("Atenção: Nenhum resultado de avaliação válido encontrado no JSON.")
+        return False
+
+    # Calcular resumo
+    total_questions = len(evaluation_results)
+    found_count = sum(1 for item in evaluation_results if "Encontrada" in item['status'])
+    coverage_percentage = (found_count / total_questions * 100) if total_questions > 0 else 0
+
+    report_date = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+
+    html_content = f"""
+<!DOCTYPE html>
+<html lang="pt-BR">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>Relatório de Cobertura da Documentação - {report_date}</title>
+    <style>
+        body {{ font-family: Arial, sans-serif; line-height: 1.6; color: #333; margin: 0; padding: 20px; background-color: #f4f4f4; }}
+        .container {{ max-width: 1200px; margin: 20px auto; background: #fff; padding: 30px; border-radius: 8px; box-shadow: 0 2px 10px rgba(0,0,0,0.1); }}
+        h1, h2, h3 {{ color: #0056b3; }}
+        h1 {{ text-align: center; margin-bottom: 30px; }}
+        .summary {{ background-color: #e9f5ff; border-left: 5px solid #0056b3; padding: 15px; margin-bottom: 30px; border-radius: 5px; }}
+        .summary p {{ margin: 5px 0; font-size: 1.1em; }}
+        .question-item {{ background-color: #f9f9f9; border: 1px solid #ddd; border-radius: 5px; margin-bottom: 20px; padding: 15px; }}
+        .question-item.found {{ border-left: 5px solid #28a745; }}
+        .question-item.not-found {{ border-left: 5px solid #dc3545; }}
+        .question-item.partial-found {{ border-left: 5px solid #ffc107; }} /* Orange for partial/other */
+        .question-item h3 {{ margin-top: 0; color: #0056b3; }}
+        .question-item p {{ margin-bottom: 8px; }}
+        .question-item strong {{ color: #555; }}
+        .details ul {{ list-style-type: none; padding: 0; }}
+        .details li {{ margin-bottom: 5px; background-color: #eee; padding: 8px; border-radius: 3px; }}
+        .details li.covered {{ background-color: #d4edda; color: #155724; }}
+        .details li.not-covered {{ background-color: #f8d7da; color: #721c24; }}
+        .chunk-list {{ margin-top: 10px; border-top: 1px dashed #ccc; padding-top: 10px; }}
+        .chunk-list h4 {{ margin-bottom: 5px; color: #0056b3; }}
+        .chunk-item {{ background-color: #e2f0f7; border: 1px solid #cce5ff; padding: 10px; margin-bottom: 5px; border-radius: 3px; font-size: 0.9em; }}
+        .chunk-item strong {{ color: #333; }}
+        .collapsible {{ cursor: pointer; padding: 10px; margin-top: 10px; background-color: #007bff; color: white; border: none; text-align: left; border-radius: 4px; width: 100%; font-size: 1em; }}
+        .collapsible:hover {{ background-color: #0056b3; }}
+        .collapsible.active:after {{ content: "\\2212"; float: right; }} /* Minus sign */
+        .collapsible:not(.active):after {{ content: "\\002B"; float: right; }} /* Plus sign */
+        .content {{ padding: 0 18px; max-height: 0; overflow: hidden; transition: max-height 0.3s ease-out; background-color: #f9f9f9; border: 1px solid #ddd; border-top: none; border-radius: 0 0 5px 5px; }}
+    </style>
+</head>
+<body>
+    <div class="container">
+        <h1>Relatório de Cobertura da Documentação</h1>
+        <p style="text-align: center; font-size: 0.9em; color: #666;">Gerado em: {report_date}</p>
+
+        <div class="summary">
+            <h2>Resumo Geral</h2>
+            <p><strong>Total de Perguntas Avaliadas:</strong> {total_questions}</p>
+            <p><strong>Perguntas com Cobertura Suficiente:</strong> {found_count}</p>
+            <p><strong>Porcentagem de Cobertura Geral:</strong> {coverage_percentage:.2f}%</p>
+        </div>
+
+        <h2>Resultados Detalhados por Pergunta</h2>
+    """
+
+    for i, item in enumerate(evaluation_results): # Iterate with index for unique IDs
+        question_class = ""
+        if "Encontrada" in item['status']:
+            question_class = "found"
+        elif "Não Encontrada" in item['status']:
+            question_class = "not-found"
+        else:
+            question_class = "partial-found"
+
+        html_content += f"""
+        <div class="question-item {question_class}">
+            <h3>{i+1}. Pergunta: {item['pergunta']}</h3>
+            <p><strong>Status:</strong> {item['status']}</p>
+            <p><strong>Resposta Ideal:</strong> {item['resposta_ideal']}</p>
+            
+            <button type="button" class="collapsible">Detalhes da Cobertura e Chunks Relevantes</button>
+            <div class="content">
+                <div class="details">
+                    <h4>Cobertura por Frase da Resposta Ideal:</h4>
+                    <ul>
+        """
+        if item.get('cobertura_detalhes'):
+            for detail in item['cobertura_detalhes']:
+                detail_class = "covered" if "Coberta" in detail['status'] else "not-covered"
+                html_content += f"""
+                        <li class="{detail_class}">
+                            <strong>Frase:</strong> {detail['frase_ideal']}<br>
+                            <strong>Status da Frase:</strong> {detail['status']}<br>
+                            <strong>Similaridade Máx. para Frase:</strong> {detail['similaridade_max']}<br>
+                            <strong>Chunk Correspondente:</strong> {detail['chunk_correspondente']}
+                        </li>
+                """
+        else:
+            html_content += "<li>Nenhum detalhe de cobertura de frase disponível.</li>"
+
+        html_content += f"""
+                    </ul>
+                </div>
+                <div class="chunk-list">
+                    <h4>Top {top_k_chunks} Chunks Relevantes para a Pergunta:</h4>
+        """ # Removed <ul> here as chunk-item can be a direct child
+        if item.get('top_k_chunks_relevantes'):
+            for chunk in item['top_k_chunks_relevantes']:
+                html_content += f"""
+                        <div class="chunk-item">
+                            <p><strong>Documento:</strong> {chunk['document_title']}</p>
+                            <p><strong>Seção:</strong> {chunk['chunk_title']}</p>
+                            <p><strong>Caminho do Arquivo:</strong> <code>{chunk['filepath']}</code></p>
+                            <p><strong>Similaridade com a Pergunta:</strong> {chunk['similarity_to_query']}</p>
+                            <p><strong>Conteúdo (preview):</strong> <pre><code>{chunk['content_preview']}</code></pre></p>
+                        </div>
+                """
+        else:
+            html_content += "<p>Nenhum chunk relevante encontrado.</p>" # Use <p> for consistency
+
+        html_content += f"""
+                </div>
+            </div>
+        </div>
+        """
+
+    html_content += """
+    </div>
+    <script>
+        var coll = document.getElementsByClassName("collapsible");
+        var i;
+
+        for (i = 0; i < coll.length; i++) {
+            coll[i].addEventListener("click", function() {
+                this.classList.toggle("active");
+                var content = this.nextElementSibling;
+                if (content.style.maxHeight){
+                    content.style.maxHeight = null;
+                } else {
+                    content.style.maxHeight = content.scrollHeight + "px";
+                } 
+            });
+        }
+    </script>
+</body>
+</html>
+    """
+
+    try:
+        with open(output_html_path, 'w', encoding='utf-8') as f:
+            f.write(html_content)
+        print(f"Relatório HTML gerado com sucesso em '{output_html_path}'.")
+        return True
+    except Exception as e:
+        print(f"Erro ao salvar o relatório HTML: {e}")
+        return False
+
+# NEW cli_main function
+def cli_main():
+    parser = argparse.ArgumentParser(description="Gera relatório HTML da avaliação de cobertura.")
+    parser.add_argument("input_file", # Changed from evaluation_json_path to match docs_tc.py call
+                        help="Arquivo JSON de entrada com os resultados da avaliação (padrão: evaluation_results.json).")
+    parser.add_argument("output_file", # Changed from output_html_path to match docs_tc.py call
+                        help="Arquivo HTML de saída para o relatório (padrão: coverage_report.html).")
+    parser.add_argument("top_k_chunks", type=int, # Changed from --top_k_chunks for positional
+                        help="Valor de top_k_chunks usado na avaliação (para consistência do relatório).")
+    args = parser.parse_args()
+
+    success = generate_html_report(
+        evaluation_json_path=args.input_file, # Use new arg name
+        output_html_path=args.output_file,    # Use new arg name
+        top_k_chunks=args.top_k_chunks
+    )
+    if not success:
+        print("A geração do relatório HTML falhou.")
+        sys.exit(1)
+    else:
+        print("Geração do relatório HTML concluída com sucesso.")
+
+if __name__ == "__main__":
+    cli_main() # Call the new cli_main