Initial commit: Complete checklist management app with AI reporting

Features:
- Multi-page Streamlit application for checklist management
- PostgreSQL integration with time tracking analytics
- Process tracking with 6-month deadline monitoring
- AI-powered analysis and executive reports with OpenAI GPT-4
- PDF export functionality with ReportLab
- Comprehensive dashboard with Plotly visualizations
- Environment variable configuration for Hugging Face Spaces deployment

🤖 Generated with [Claude Code](https://claude.ai/code)

Co-Authored-By: Claude <noreply@anthropic.com>

.env.example

@@ -0,0 +1,2 @@
+# Configurações para Relatórios com IA
+OPENAI_API_KEY=sua_chave_openai_aqui

.gitignore

@@ -0,0 +1,204 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+cover/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+.pybuilder/
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+#   For a library or package, you might want to ignore these files since the code is
+#   intended to run in multiple environments; otherwise, check them in:
+# .python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# poetry
+#   Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#   https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control
+#poetry.lock
+
+# pdm
+#   Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control.
+#pdm.lock
+#   pdm stores project-wide configurations in .pdm.toml, but it is recommended to not include it
+#   in version control.
+#   https://pdm.fming.dev/#use-with-ide
+.pdm.toml
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# Cython debug symbols
+cython_debug/
+
+# PyCharm
+#  JetBrains specific template is maintained in a separate JetBrains.gitignore that can
+#  be added to the global gitignore or merged into this project gitignore.  For a PyCharm
+#  project, it is common to ignore common working directory configurations.
+.idea/
+
+# VS Code
+.vscode/
+
+# Arquivos de teste e desenvolvimento
+test_*.py
+*_test.py
+tests/
+test/
+
+# Arquivos de criação e configuração do banco
+create_tables.sql
+add_numero_processo.sql
+test_db.py
+
+# Arquivos de configuração local
+.env.local
+.env.development
+config.ini
+
+# Arquivos de backup
+*.bak
+*.backup
+*.tmp
+
+# Logs
+*.log
+logs/
+
+# Dados temporários
+temp/
+tmp/
+
+# OS generated files
+.DS_Store
+.DS_Store?
+._*
+.Spotlight-V100
+.Trashes
+ehthumbs.db
+Thumbs.db
+
+# Specific project files to ignore
+CLAUDE.md
+README_local.md

README.md

@@ -0,0 +1,100 @@
+# 🗂️ Gerenciador de Checklists
+
+Aplicativo completo para gerenciamento de checklists com análise de tempo e relatórios inteligentes.
+
+## 🚀 Funcionalidades
+
+- ✅ **Criação de Checklists Personalizados**
+- 📊 **Dashboard Geral com Analytics**
+- ⏱️ **Análise de Tempo e Movimentos**
+- 🎯 **Controle de Prazos (6 meses)**
+- 🤖 **Relatórios com IA (GPT-4)**
+- 📄 **Export para PDF**
+- 🔢 **Rastreamento por Número de Processo**
+
+## 🛠️ Tecnologias
+
+- **Frontend**: Streamlit
+- **Banco de Dados**: PostgreSQL
+- **IA**: OpenAI GPT-4
+- **Visualização**: Plotly, Matplotlib, Seaborn
+- **PDF**: ReportLab
+
+## 📦 Dependências
+
+```bash
+pip install -r requirements.txt
+```
+
+## ⚙️ Configuração
+
+### Variáveis de Ambiente
+
+O aplicativo utiliza as seguintes variáveis de ambiente:
+
+#### Banco de Dados
+- `DB_HOST`: Host do PostgreSQL
+- `DB_PORT`: Porta (padrão: 5432)
+- `DB_NAME`: Nome do banco
+- `DB_USER`: Usuário
+- `DB_PASSWORD`: Senha
+
+#### IA (OpenAI)
+- `OPENAI_API_KEY`: Chave da API OpenAI para relatórios
+
+### Para Desenvolvimento Local
+
+Crie um arquivo `.env`:
+```env
+OPENAI_API_KEY=sua_chave_openai_aqui
+DB_HOST=seu_host
+DB_PORT=5432
+DB_NAME=checklist
+DB_USER=usuario
+DB_PASSWORD=senha
+```
+
+## 🚀 Como Usar
+
+1. **Criar Checklist**: Clique em "➕ Novo Checklist"
+2. **Visualizar**: Acesse via "📊 Dashboard Geral" 
+3. **Análise**: Use "🤖 Relatórios IA" para insights
+4. **Monitorar**: Acompanhe prazos e progresso
+
+## 📊 Analytics
+
+- Tempo médio por processo
+- Taxa de conclusão
+- Análise de riscos de prazo
+- Identificação de gargalos
+- Relatórios executivos
+
+## 🤖 IA e Relatórios
+
+- Análise automática de padrões
+- Identificação de ineficiências
+- Recomendações estratégicas
+- Relatórios executivos em PDF
+
+## 🏗️ Estrutura do Projeto
+
+```
+checklist/
+├── app.py                 # Aplicação principal
+├── pages/                 # Páginas do Streamlit
+│   ├── criar_checklist.py # Criação de checklists
+│   ├── dashboard.py       # Dashboard individual
+│   ├── dashboard_geral.py # Dashboard geral
+│   ├── analytics.py       # Análise de tempo
+│   └── relatorio_ia.py    # Relatórios com IA
+├── utils/
+│   └── database.py        # Conexão e operações DB
+├── requirements.txt       # Dependências Python
+└── README.md             # Este arquivo
+```
+
+## 📈 Métricas Importantes
+
+- **Prazo Ideal**: 6 meses por processo
+- **Status de Prazo**: NO_PRAZO, EM_RISCO, RISCO_ATRASO, ATRASADO
+- **Análise de Velocidade**: Baseada em interações dos usuários

app.py

@@ -0,0 +1,76 @@
+"""Aplicativo de Gerenciamento de Checklists"""
+
+import streamlit as st
+from utils.database import get_all_checklists, test_connection
+
+st.set_page_config(
+    page_title="Gerenciador de Checklists",
+    page_icon="✅",
+    layout="centered",
+    initial_sidebar_state="collapsed"
+)
+
+def init_session_state():
+    if 'current_checklist_id' not in st.session_state:
+        st.session_state.current_checklist_id = None
+
+def main():
+    init_session_state()
+    
+    st.title("🗂️ Gerenciador de Checklists")
+    st.markdown("---")
+    
+    # Testar conexão com banco
+    if not test_connection():
+        st.error("❌ Erro ao conectar com o banco de dados!")
+        st.stop()
+    
+    col1, col2, col3 = st.columns([1, 2, 1])
+    
+    with col2:
+        st.markdown("### Bem-vindo!")
+        st.markdown("Crie e gerencie seus checklists personalizados de forma simples e eficiente.")
+        
+        st.markdown("")
+        
+        col1, col2, col3 = st.columns(3)
+        with col1:
+            if st.button("➕ Novo Checklist", type="primary", use_container_width=True):
+                st.switch_page("pages/criar_checklist.py")
+        with col2:
+            if st.button("📊 Dashboard Geral", use_container_width=True):
+                st.switch_page("pages/dashboard_geral.py")
+        with col3:
+            if st.button("🤖 Relatórios IA", use_container_width=True):
+                st.switch_page("pages/relatorio_ia.py")
+        
+        # Buscar checklists do banco
+        try:
+            checklists = get_all_checklists()
+            
+            if checklists:
+                st.markdown("### Seus Checklists")
+                for checklist in checklists:
+                    col_name, col_process, col_date, col_btn = st.columns([3, 2, 1.5, 1])
+                    with col_name:
+                        st.write(f"📋 {checklist['name']}")
+                    with col_process:
+                        if checklist['numero_processo']:
+                            st.caption(f"🔢 {checklist['numero_processo']}")
+                        else:
+                            st.caption("🔢 Sem processo")
+                    with col_date:
+                        st.caption(checklist['created_at'].strftime("%d/%m/%Y"))
+                    with col_btn:
+                        if st.button("Ver", key=f"view_{checklist['id']}"):
+                            st.session_state.current_checklist_id = checklist['id']
+                            st.switch_page("pages/dashboard.py")
+            else:
+                st.info("Você ainda não tem checklists. Clique em 'Novo Checklist' para criar o primeiro!")
+                
+        except Exception as e:
+            st.error(f"Erro ao buscar checklists: {str(e)}")
+
+if __name__ == "__main__":
+    main()
+

pages/analytics.py

@@ -0,0 +1,197 @@
+"""Página de análises de tempo e movimentos do checklist"""
+
+import streamlit as st
+import pandas as pd
+import plotly.express as px
+import plotly.graph_objects as go
+from utils.database import get_checklist_analytics, get_checklist_with_items
+from datetime import datetime, timedelta
+
+st.set_page_config(
+    page_title="Análises de Tempo",
+    page_icon="📊",
+    layout="wide"
+)
+
+def format_time(seconds):
+    """Formata segundos em formato legível"""
+    if seconds is None or seconds == 0:
+        return "0s"
+    
+    if seconds < 60:
+        return f"{int(seconds)}s"
+    elif seconds < 3600:
+        minutes = int(seconds // 60)
+        secs = int(seconds % 60)
+        return f"{minutes}m {secs}s"
+    else:
+        hours = int(seconds // 3600)
+        minutes = int((seconds % 3600) // 60)
+        return f"{hours}h {minutes}m"
+
+def main():
+    if 'current_checklist_id' not in st.session_state or st.session_state.current_checklist_id is None:
+        st.error("Nenhum checklist selecionado!")
+        if st.button("← Voltar para Início"):
+            st.switch_page("app.py")
+        return
+    
+    checklist_id = st.session_state.current_checklist_id
+    
+    try:
+        # Buscar dados do checklist
+        checklist = get_checklist_with_items(checklist_id)
+        analytics = get_checklist_analytics(checklist_id)
+        
+        if not checklist:
+            st.error("Checklist não encontrado!")
+            return
+        
+        # Header
+        col1, col2 = st.columns([5, 1])
+        with col1:
+            st.title(f"📊 Análises: {checklist['name']}")
+            if checklist['numero_processo']:
+                st.caption(f"🔢 Processo: {checklist['numero_processo']}")
+        with col2:
+            if st.button("← Voltar"):
+                st.switch_page("pages/dashboard.py")
+        
+        st.markdown("---")
+        
+        # Estatísticas gerais
+        stats = analytics['stats']
+        time_analysis = analytics['time_analysis']
+        
+        if stats['first_interaction'] and stats['last_interaction']:
+            total_time = stats['last_interaction'] - stats['first_interaction']
+            total_minutes = total_time.total_seconds() / 60
+        else:
+            total_minutes = 0
+        
+        col1, col2, col3, col4 = st.columns(4)
+        
+        with col1:
+            st.metric("Total de Items", stats['total_items'])
+        with col2:
+            st.metric("Items Concluídos", stats['completed_items'])
+        with col3:
+            completion_rate = (stats['completed_items'] / stats['total_items']) * 100 if stats['total_items'] > 0 else 0
+            st.metric("Taxa de Conclusão", f"{completion_rate:.1f}%")
+        with col4:
+            st.metric("Tempo Total", format_time(total_minutes * 60))
+        
+        st.markdown("---")
+        
+        # Análise por item
+        if time_analysis:
+            st.markdown("### 📈 Análise de Tempo por Item")
+            
+            # Criar DataFrame para visualização
+            df_time = pd.DataFrame(time_analysis)
+            
+            # Converter colunas para tipos numéricos corretos
+            df_time['total_seconds_spent'] = pd.to_numeric(df_time['total_seconds_spent'], errors='coerce').fillna(0)
+            df_time['avg_seconds_per_completion'] = pd.to_numeric(df_time['avg_seconds_per_completion'], errors='coerce').fillna(0)
+            df_time['times_worked'] = pd.to_numeric(df_time['times_worked'], errors='coerce').fillna(0).astype(int)
+            
+            df_time['tempo_formatado'] = df_time['total_seconds_spent'].apply(lambda x: format_time(x) if x else "0s")
+            df_time['tempo_medio_formatado'] = df_time['avg_seconds_per_completion'].apply(lambda x: format_time(x) if x else "0s")
+            df_time['vezes_trabalhado'] = df_time['times_worked']
+            
+            # Gráfico de barras - Tempo total por item
+            if not df_time.empty and df_time['total_seconds_spent'].sum() > 0:
+                fig_time = px.bar(
+                    df_time.sort_values('total_seconds_spent', ascending=False),
+                    x='item_text',
+                    y='total_seconds_spent',
+                    title="Tempo Total Gasto por Item",
+                    labels={'total_seconds_spent': 'Tempo (segundos)', 'item_text': 'Item'}
+                )
+                fig_time.update_layout(xaxis_tickangle=-45)
+                st.plotly_chart(fig_time, use_container_width=True)
+                
+                # Gráfico de pizza - Distribuição do tempo
+                df_positive = df_time[df_time['total_seconds_spent'] > 0]
+                if not df_positive.empty:
+                    fig_pie = px.pie(
+                        df_positive,
+                        values='total_seconds_spent',
+                        names='item_text',
+                        title="Distribuição do Tempo por Item"
+                    )
+                    st.plotly_chart(fig_pie, use_container_width=True)
+            
+            # Tabela detalhada
+            st.markdown("### 📋 Detalhes por Item")
+            
+            df_display = df_time[['item_text', 'vezes_trabalhado', 'tempo_formatado', 'tempo_medio_formatado']].copy()
+            df_display.columns = ['Item', 'Vezes Trabalhado', 'Tempo Total', 'Tempo Médio']
+            
+            # Ordenar pela coluna numérica original
+            df_display = df_display.loc[df_time.sort_values('total_seconds_spent', ascending=False).index]
+            
+            st.dataframe(df_display, use_container_width=True)
+            
+            # Insights automáticos
+            st.markdown("### 🔍 Insights")
+            
+            col1, col2 = st.columns(2)
+            
+            with col1:
+                st.markdown("#### Items mais demorados")
+                if not df_time.empty and df_time['total_seconds_spent'].sum() > 0:
+                    top_slow = df_time.sort_values('total_seconds_spent', ascending=False).head(3)
+                    for _, item in top_slow.iterrows():
+                        if item['total_seconds_spent'] > 0:
+                            st.write(f"• **{item['item_text']}**: {item['tempo_formatado']}")
+                else:
+                    st.info("Nenhum dado de tempo disponível ainda.")
+            
+            with col2:
+                st.markdown("#### Items mais retrabalhados")
+                if not df_time.empty and df_time['times_worked'].sum() > 0:
+                    top_rework = df_time.sort_values('times_worked', ascending=False).head(3)
+                    for _, item in top_rework.iterrows():
+                        if item['times_worked'] > 1:
+                            st.write(f"• **{item['item_text']}**: {item['times_worked']} vezes")
+                else:
+                    st.info("Nenhum retrabalho identificado.")
+            
+            # Recomendações
+            st.markdown("#### 💡 Recomendações")
+            
+            if not df_time.empty and df_time['total_seconds_spent'].sum() > 0:
+                mean_time = df_time['total_seconds_spent'].mean()
+                slow_items = df_time[df_time['total_seconds_spent'] > mean_time]['item_text'].tolist()
+                rework_items = df_time[df_time['times_worked'] > 1]['item_text'].tolist()
+                
+                if slow_items:
+                    st.warning(f"**Items que demandam mais tempo:** {', '.join(slow_items[:3])}")
+                    st.write("💡 Considere revisar estes items ou dividir em subtarefas menores.")
+                
+                if rework_items:
+                    st.info(f"**Items com retrabalho:** {', '.join(rework_items[:3])}")
+                    st.write("💡 Analise se estes items precisam de mais clareza ou recursos adicionais.")
+                
+                if not slow_items and not rework_items:
+                    st.success("✅ Ótimo trabalho! O checklist está sendo executado de forma eficiente.")
+            elif not df_time.empty:
+                st.info("📊 Marque e desmarque alguns items para gerar recomendações baseadas no tempo de execução.")
+            
+        else:
+            st.info("📊 Ainda não há dados suficientes para análise. Continue marcando os items do checklist para gerar insights.")
+            
+            # Mostrar checklist atual
+            st.markdown("### 📋 Status Atual dos Items")
+            for item in checklist['items']:
+                status = "✅" if item['is_checked'] else "⏳"
+                st.write(f"{status} {item['text']}")
+        
+    except Exception as e:
+        st.error(f"Erro ao carregar análises: {str(e)}")
+        if st.button("← Voltar para Dashboard"):
+            st.switch_page("pages/dashboard.py")
+
+if __name__ == "__main__":
+    main()

pages/criar_checklist.py

@@ -0,0 +1,130 @@
+"""Página para criar novo checklist"""
+
+import streamlit as st
+from utils.database import save_checklist as save_checklist_db
+
+st.set_page_config(
+    page_title="Criar Novo Checklist",
+    page_icon="✅",
+    layout="centered"
+)
+
+def init_form_state():
+    if 'form_items' not in st.session_state:
+        st.session_state.form_items = []
+    if 'item_to_remove' not in st.session_state:
+        st.session_state.item_to_remove = None
+
+def add_item():
+    st.session_state.form_items.append("")
+
+def remove_item(index):
+    st.session_state.form_items.pop(index)
+
+def save_checklist(name, items, numero_processo):
+    if not name:
+        st.error("Por favor, dê um nome ao seu checklist!")
+        return False
+    
+    if not numero_processo:
+        st.error("Por favor, informe o número do processo!")
+        return False
+    
+    if not items or all(item == "" for item in items):
+        st.error("Por favor, adicione pelo menos um item ao checklist!")
+        return False
+    
+    try:
+        # Salvar no banco de dados
+        checklist_id = save_checklist_db(name, items, numero_processo)
+        st.session_state.current_checklist_id = checklist_id
+        
+        # Limpar os dados para próximo uso
+        st.session_state.form_items = []
+        if 'should_clear' not in st.session_state:
+            st.session_state.should_clear = False
+        st.session_state.should_clear = True
+        
+        return True
+    except Exception as e:
+        st.error(f"Erro ao salvar checklist: {str(e)}")
+        return False
+
+def main():
+    init_form_state()
+    
+    st.title("📝 Criar Novo Checklist")
+    
+    col1, col2 = st.columns([5, 1])
+    with col1:
+        st.markdown("---")
+    with col2:
+        if st.button("← Voltar"):
+            st.switch_page("app.py")
+    
+    # Verifica se deve limpar o formulário após salvar
+    if 'should_clear' in st.session_state and st.session_state.should_clear:
+        st.session_state.should_clear = False
+        st.switch_page("pages/dashboard.py")
+    
+    if st.session_state.item_to_remove is not None:
+        remove_item(st.session_state.item_to_remove)
+        st.session_state.item_to_remove = None
+        st.rerun()
+    
+    with st.container():
+        col1, col2 = st.columns(2)
+        
+        with col1:
+            checklist_name = st.text_input(
+                "Nome do Checklist",
+                key="checklist_name_input",
+                placeholder="Ex: Tarefas do Projeto X"
+            )
+        
+        with col2:
+            numero_processo = st.text_input(
+                "Número do Processo",
+                key="numero_processo_input",
+                placeholder="Ex: PROC-2024-001"
+            )
+        
+        st.markdown("### Items do Checklist")
+        
+        if not st.session_state.form_items:
+            st.info("Clique em 'Adicionar Item' para começar a criar seu checklist")
+        
+        current_items = []
+        for i, item in enumerate(st.session_state.form_items):
+            col1, col2 = st.columns([5, 1])
+            with col1:
+                item_value = st.text_input(
+                    f"Item {i+1}",
+                    value=item,
+                    key=f"item_{i}",
+                    placeholder="Digite o item do checklist"
+                )
+                current_items.append(item_value)
+            with col2:
+                st.markdown("<br>", unsafe_allow_html=True)
+                if st.button("🗑️", key=f"remove_{i}", help="Remover item"):
+                    st.session_state.item_to_remove = i
+                    st.rerun()
+        
+        st.markdown("")
+        
+        col1, col2, col3 = st.columns([2, 2, 2])
+        
+        with col1:
+            if st.button("➕ Adicionar Item", use_container_width=True):
+                add_item()
+                st.rerun()
+        
+        with col3:
+            if st.button("💾 Salvar Checklist", type="primary", use_container_width=True):
+                if save_checklist(checklist_name, current_items, numero_processo):
+                    st.success("Checklist criado com sucesso!")
+                    st.balloons()
+
+if __name__ == "__main__":
+    main()

pages/dashboard.py

@@ -0,0 +1,108 @@
+"""Página do dashboard para visualizar e interagir com o checklist"""
+
+import streamlit as st
+from utils.database import get_checklist_with_items, toggle_item as toggle_item_db
+
+st.set_page_config(
+    page_title="Dashboard do Checklist",
+    page_icon="✅",
+    layout="centered"
+)
+
+def get_progress(items):
+    if not items:
+        return 0
+    checked_count = sum(1 for item in items if item['is_checked'])
+    return (checked_count / len(items)) * 100
+
+def main():
+    if 'current_checklist_id' not in st.session_state or st.session_state.current_checklist_id is None:
+        st.error("Nenhum checklist selecionado!")
+        if st.button("← Voltar para Início"):
+            st.switch_page("app.py")
+        return
+    
+    checklist_id = st.session_state.current_checklist_id
+    
+    try:
+        # Buscar checklist do banco
+        checklist = get_checklist_with_items(checklist_id)
+        
+        if not checklist:
+            st.error("Checklist não encontrado!")
+            if st.button("← Voltar para Início"):
+                st.switch_page("app.py")
+            return
+        
+        col1, col2, col3 = st.columns([4, 1, 1])
+        with col1:
+            st.title(f"📋 {checklist['name']}")
+            if checklist['numero_processo']:
+                st.caption(f"🔢 Processo: {checklist['numero_processo']}")
+        with col2:
+            if st.button("📊 Análises"):
+                st.switch_page("pages/analytics.py")
+        with col3:
+            if st.button("← Voltar"):
+                st.switch_page("app.py")
+        
+        st.markdown("---")
+        
+        progress = get_progress(checklist['items'])
+        
+        col1, col2 = st.columns([3, 1])
+        with col1:
+            st.progress(progress / 100)
+        with col2:
+            st.metric("Progresso", f"{progress:.0f}%")
+        
+        st.markdown("### Items do Checklist")
+        
+        if not checklist['items']:
+            st.info("Este checklist não possui items.")
+        else:
+            for item in checklist['items']:
+                col1, col2 = st.columns([10, 1])
+                
+                with col1:
+                    current_state = item['is_checked']
+                    new_state = st.checkbox(
+                        item['text'],
+                        value=current_state,
+                        key=f"check_{item['id']}"
+                    )
+                    
+                    # Se o estado mudou, atualizar no banco
+                    if new_state != current_state:
+                        try:
+                            toggle_item_db(item['id'], checklist_id, new_state)
+                            st.rerun()
+                        except Exception as e:
+                            st.error(f"Erro ao atualizar item: {str(e)}")
+        
+        items_total = len(checklist['items'])
+        items_checked = sum(1 for item in checklist['items'] if item['is_checked'])
+        items_remaining = items_total - items_checked
+        
+        st.markdown("---")
+        
+        col1, col2, col3 = st.columns(3)
+        
+        with col1:
+            st.metric("Total de Items", items_total)
+        with col2:
+            st.metric("Concluídos", items_checked, delta=f"{items_checked}/{items_total}")
+        with col3:
+            st.metric("Restantes", items_remaining)
+        
+        if progress == 100:
+            st.success("🎉 Parabéns! Você completou todo o checklist!")
+            st.balloons()
+            
+    except Exception as e:
+        st.error(f"Erro ao carregar checklist: {str(e)}")
+        if st.button("← Voltar para Início"):
+            st.switch_page("app.py")
+
+if __name__ == "__main__":
+    main()

pages/dashboard_geral.py

@@ -0,0 +1,501 @@
+"""Dashboard Geral - Análise de todos os checklists"""
+
+import streamlit as st
+import pandas as pd
+import plotly.express as px
+import plotly.graph_objects as go
+from datetime import datetime, timedelta
+from utils.database import (
+    get_all_checklists_with_stats, 
+    get_general_stats, 
+    get_checklist_interactions_summary,
+    get_process_summary,
+    get_fastest_processes,
+    get_process_deadline_analysis,
+    test_connection
+)
+
+st.set_page_config(
+    page_title="Dashboard Geral - Checklists",
+    page_icon="📊",
+    layout="wide"
+)
+
+st.title("📊 Painel Geral - Análise de Todos os Checklists")
+
+# Função para carregar dados
+@st.cache_data(ttl=300)  # Cache por 5 minutos
+def carregar_dados():
+    """Carrega todos os dados necessários"""
+    try:
+        if not test_connection():
+            return None, None, None, None, None, None
+            
+        checklists = get_all_checklists_with_stats()
+        stats = get_general_stats()
+        interactions = get_checklist_interactions_summary()
+        processes = get_process_summary()
+        fastest_processes = get_fastest_processes()
+        deadline_analysis = get_process_deadline_analysis()
+        
+        return checklists, stats, interactions, processes, fastest_processes, deadline_analysis
+    except Exception as e:
+        st.error(f"❌ Erro ao carregar dados: {str(e)}")
+        return None, None, None, None, None, None
+
+# Botão para atualizar dados
+col1, col2 = st.columns([6, 1])
+with col2:
+    if st.button("🔄 Atualizar Dados"):
+        st.cache_data.clear()
+        st.rerun()
+
+with col1:
+    if st.button("← Voltar para Início"):
+        st.switch_page("app.py")
+
+# Carrega os dados
+resultado = carregar_dados()
+if resultado is None or len(resultado) != 6:
+    st.error("❌ Erro ao conectar com o banco de dados ou dados não disponíveis!")
+    st.stop()
+
+checklists, stats, interactions, processes, fastest_processes, deadline_analysis = resultado
+
+if not checklists or not stats:
+    st.error("❌ Erro ao conectar com o banco de dados ou dados não disponíveis!")
+    st.stop()
+
+# Converte para DataFrame
+df_checklists = pd.DataFrame(checklists)
+df_interactions = pd.DataFrame(interactions) if interactions else pd.DataFrame()
+df_processes = pd.DataFrame(processes) if processes else pd.DataFrame()
+df_fastest = pd.DataFrame(fastest_processes) if fastest_processes else pd.DataFrame()
+df_deadlines = pd.DataFrame(deadline_analysis) if deadline_analysis else pd.DataFrame()
+
+# Converter colunas numéricas para tipos corretos
+if not df_checklists.empty:
+    df_checklists['progress_percentage'] = pd.to_numeric(df_checklists['progress_percentage'], errors='coerce').fillna(0)
+    df_checklists['total_items'] = pd.to_numeric(df_checklists['total_items'], errors='coerce').fillna(0)
+    df_checklists['completed_items'] = pd.to_numeric(df_checklists['completed_items'], errors='coerce').fillna(0)
+
+if not df_interactions.empty:
+    df_interactions['total_interactions'] = pd.to_numeric(df_interactions['total_interactions'], errors='coerce').fillna(0)
+
+if not df_processes.empty:
+    df_processes['avg_progress'] = pd.to_numeric(df_processes['avg_progress'], errors='coerce').fillna(0)
+    df_processes['total_checklists'] = pd.to_numeric(df_processes['total_checklists'], errors='coerce').fillna(0)
+    df_processes['total_items'] = pd.to_numeric(df_processes['total_items'], errors='coerce').fillna(0)
+    df_processes['completed_items'] = pd.to_numeric(df_processes['completed_items'], errors='coerce').fillna(0)
+
+if not df_fastest.empty:
+    df_fastest['avg_progress'] = pd.to_numeric(df_fastest['avg_progress'], errors='coerce').fillna(0)
+    df_fastest['total_checklists'] = pd.to_numeric(df_fastest['total_checklists'], errors='coerce').fillna(0)
+    df_fastest['avg_completion_hours'] = pd.to_numeric(df_fastest['avg_completion_hours'], errors='coerce').fillna(0)
+    df_fastest['avg_start_hours'] = pd.to_numeric(df_fastest['avg_start_hours'], errors='coerce').fillna(0)
+    df_fastest['total_avg_time_hours'] = pd.to_numeric(df_fastest['total_avg_time_hours'], errors='coerce').fillna(0)
+
+if not df_deadlines.empty:
+    df_deadlines['avg_progress'] = pd.to_numeric(df_deadlines['avg_progress'], errors='coerce').fillna(0)
+    df_deadlines['days_elapsed'] = pd.to_numeric(df_deadlines['days_elapsed'], errors='coerce').fillna(0)
+    df_deadlines['days_remaining'] = pd.to_numeric(df_deadlines['days_remaining'], errors='coerce').fillna(0)
+    df_deadlines['projected_days_to_complete'] = pd.to_numeric(df_deadlines['projected_days_to_complete'], errors='coerce').fillna(0)
+
+if df_checklists.empty:
+    st.warning("📭 Nenhum checklist encontrado no banco de dados.")
+    st.info("💡 Clique em 'Novo Checklist' na página inicial para criar o primeiro checklist.")
+else:
+    # =================== MÉTRICA DE PRAZO IDEAL ===================
+    st.markdown("---")
+    st.info("⏰ **Tempo Médio Ideal de Execução do Processo: 6 meses (180 dias)**")
+    
+    # Estatísticas de prazo
+    if not df_deadlines.empty:
+        status_counts = df_deadlines['status_prazo'].value_counts()
+        
+        col1, col2, col3, col4, col5 = st.columns(5)
+        
+        with col1:
+            concluidos = status_counts.get('CONCLUIDO', 0)
+            st.metric("✅ Concluídos", concluidos)
+        
+        with col2:
+            no_prazo = status_counts.get('NO_PRAZO', 0)
+            st.metric("🟢 No Prazo", no_prazo)
+        
+        with col3:
+            em_risco = status_counts.get('EM_RISCO', 0)
+            st.metric("🟡 Em Risco", em_risco)
+        
+        with col4:
+            risco_atraso = status_counts.get('RISCO_ATRASO', 0)
+            st.metric("🟠 Alto Risco", risco_atraso)
+        
+        with col5:
+            atrasados = status_counts.get('ATRASADO', 0)
+            st.metric("🔴 Atrasados", atrasados)
+    # =================== MÉTRICAS GERAIS ===================
+    st.markdown("---")
+    st.subheader("📈 Métricas Gerais")
+    
+    col1, col2, col3, col4, col5 = st.columns(5)
+    
+    with col1:
+        st.metric("🗂️ Total de Checklists", stats['total_checklists'])
+    
+    with col2:
+        st.metric("🔢 Processos Únicos", stats['total_processos'] or 0)
+    
+    with col3:
+        completed_checklists = stats['completed_checklists'] or 0
+        completion_rate = (completed_checklists / stats['total_checklists']) * 100 if stats['total_checklists'] > 0 else 0
+        st.metric("✅ Checklists Concluídos", f"{completed_checklists} ({completion_rate:.1f}%)")
+    
+    with col4:
+        total_items = stats['total_items'] or 0
+        completed_items = stats['completed_items'] or 0
+        items_completion = (completed_items / total_items) * 100 if total_items > 0 else 0
+        st.metric("📋 Items Concluídos", f"{completed_items}/{total_items} ({items_completion:.1f}%)")
+    
+    with col5:
+        avg_progress = stats['avg_progress'] or 0
+        st.metric("📊 Progresso Médio", f"{avg_progress:.1f}%")
+    
+    # =================== GRÁFICOS - LINHA 1 ===================
+    st.markdown("---")
+    st.subheader("📊 Análise por Status e Processo")
+    
+    col1, col2 = st.columns(2)
+    
+    with col1:
+        # Gráfico de progresso dos checklists
+        st.markdown("#### 📈 Distribuição de Progresso")
+        
+        # Criar faixas de progresso
+        df_checklists['faixa_progresso'] = pd.cut(
+            df_checklists['progress_percentage'], 
+            bins=[0, 25, 50, 75, 100], 
+            labels=['0-25%', '26-50%', '51-75%', '76-100%'],
+            include_lowest=True
+        )
+        
+        progress_counts = df_checklists['faixa_progresso'].value_counts().sort_index()
+        
+        fig_progress = px.pie(
+            values=progress_counts.values,
+            names=progress_counts.index,
+            title="Distribuição de Checklists por Faixa de Progresso",
+            color_discrete_sequence=['#ff6b6b', '#feca57', '#48dbfb', '#1dd1a1']
+        )
+        st.plotly_chart(fig_progress, use_container_width=True)
+    
+    with col2:
+        # Gráfico de processos mais rápidos
+        st.markdown("#### ⚡ Top 10 Processos Mais Rápidos")
+        
+        if not df_fastest.empty:
+            # Função para formatar tempo em horas
+            def format_hours(hours):
+                if pd.isna(hours) or hours == 0:
+                    return "0h"
+                if hours < 1:
+                    minutes = int(hours * 60)
+                    return f"{minutes}min"
+                elif hours < 24:
+                    return f"{hours:.1f}h"
+                else:
+                    days = int(hours // 24)
+                    remaining_hours = hours % 24
+                    return f"{days}d {remaining_hours:.1f}h"
+            
+            # Preparar dados para o gráfico
+            df_fastest_display = df_fastest.head(10).copy()
+            df_fastest_display['tempo_formatado'] = df_fastest_display['total_avg_time_hours'].apply(format_hours)
+            
+            fig_fastest = px.bar(
+                df_fastest_display,
+                x='numero_processo',
+                y='total_avg_time_hours',
+                title="Processos Mais Rápidos (Menor Tempo Médio)",
+                color='avg_progress',
+                color_continuous_scale="RdYlGn",
+                hover_data=['tempo_formatado', 'total_checklists']
+            )
+            fig_fastest.update_layout(
+                xaxis_tickangle=45,
+                yaxis_title="Tempo Médio (horas)"
+            )
+            st.plotly_chart(fig_fastest, use_container_width=True)
+        else:
+            st.info("Dados de tempo não disponíveis ainda. Execute alguns checklists para gerar métricas de velocidade.")
+    
+    # =================== ANÁLISE DE PRAZOS ===================
+    if not df_deadlines.empty:
+        st.markdown("---")
+        st.subheader("🚨 Análise de Cumprimento de Prazos")
+        
+        col1, col2 = st.columns(2)
+        
+        with col1:
+            # Gráfico de status de prazos
+            st.markdown("#### 📊 Distribuição por Status de Prazo")
+            
+            status_counts = df_deadlines['status_prazo'].value_counts()
+            
+            # Mapeamento de cores por status
+            color_map = {
+                'CONCLUIDO': '#1dd1a1',    # Verde
+                'NO_PRAZO': '#00d2d3',     # Azul claro
+                'EM_RISCO': '#feca57',     # Amarelo
+                'RISCO_ATRASO': '#ff9ff3', # Laranja
+                'ATRASADO': '#ff6b6b',     # Vermelho
+                'SEM_DADOS': '#c7ecee'     # Cinza
+            }
+            
+            colors = [color_map.get(status, '#c7ecee') for status in status_counts.index]
+            
+            fig_status = px.pie(
+                values=status_counts.values,
+                names=status_counts.index,
+                title="Status dos Processos em Relação ao Prazo de 6 Meses",
+                color_discrete_sequence=colors
+            )
+            st.plotly_chart(fig_status, use_container_width=True)
+        
+        with col2:
+            # Gráfico de processos que não vão finalizar no prazo
+            st.markdown("#### 🚨 Processos em Risco ou Atrasados")
+            
+            processos_problema = df_deadlines[df_deadlines['status_prazo'].isin(['RISCO_ATRASO', 'ATRASADO', 'EM_RISCO'])]
+            
+            if not processos_problema.empty:
+                # Calcular dias totais previstos
+                processos_problema = processos_problema.copy()
+                processos_problema['dias_totais_previstos'] = processos_problema['days_elapsed'] + processos_problema['projected_days_to_complete']
+                
+                fig_problema = px.bar(
+                    processos_problema.head(10),
+                    x='numero_processo',
+                    y='dias_totais_previstos',
+                    color='status_prazo',
+                    title="Projeção de Dias Totais vs Prazo (180 dias)",
+                    color_discrete_map={
+                        'EM_RISCO': '#feca57',
+                        'RISCO_ATRASO': '#ff9ff3', 
+                        'ATRASADO': '#ff6b6b'
+                    },
+                    hover_data=['avg_progress', 'days_remaining']
+                )
+                
+                # Adicionar linha de referência do prazo
+                fig_problema.add_hline(y=180, line_dash="dash", line_color="red", 
+                                     annotation_text="Prazo Limite (180 dias)")
+                
+                fig_problema.update_layout(xaxis_tickangle=45)
+                st.plotly_chart(fig_problema, use_container_width=True)
+            else:
+                st.success("🎉 Todos os processos estão dentro do prazo!")
+    
+    # =================== GRÁFICOS - LINHA 2 ===================
+    st.markdown("---")
+    st.subheader("📅 Análise Temporal")
+    
+    col1, col2 = st.columns(2)
+    
+    with col1:
+        # Checklists criados ao longo do tempo
+        st.markdown("#### 📅 Criação de Checklists ao Longo do Tempo")
+        
+        df_checklists['data_criacao'] = pd.to_datetime(df_checklists['created_at']).dt.date
+        checklists_diarios = df_checklists.groupby('data_criacao').size().reset_index(name='quantidade')
+        
+        fig_temporal = px.line(
+            checklists_diarios,
+            x='data_criacao',
+            y='quantidade',
+            title="Checklists Criados por Dia",
+            markers=True
+        )
+        st.plotly_chart(fig_temporal, use_container_width=True)
+    
+    with col2:
+        # Progresso médio por data de criação
+        st.markdown("#### 📊 Progresso Médio por Período")
+        
+        progress_temporal = df_checklists.groupby('data_criacao')['progress_percentage'].mean().reset_index()
+        
+        fig_progress_temporal = px.bar(
+            progress_temporal,
+            x='data_criacao',
+            y='progress_percentage',
+            title="Progresso Médio dos Checklists por Data de Criação",
+            color='progress_percentage',
+            color_continuous_scale="RdYlGn"
+        )
+        st.plotly_chart(fig_progress_temporal, use_container_width=True)
+    
+    # =================== ANÁLISE DE INTERAÇÕES ===================
+    if not df_interactions.empty:
+        st.markdown("---")
+        st.subheader("🔄 Análise de Atividade")
+        
+        col1, col2 = st.columns(2)
+        
+        with col1:
+            # Processos mais ativos
+            st.markdown("#### 🔥 Processos Mais Ativos")
+            
+            if not df_interactions.empty:
+                # Agrupar por processo e somar interações
+                process_activity = df_interactions.groupby('numero_processo').agg({
+                    'total_interactions': 'sum',
+                    'name': 'count'  # contando quantos checklists por processo
+                }).reset_index()
+                process_activity.columns = ['numero_processo', 'total_interactions', 'total_checklists']
+                process_activity = process_activity.sort_values('total_interactions', ascending=False).head(10)
+                
+                fig_active = px.bar(
+                    process_activity,
+                    x='total_interactions',
+                    y='numero_processo',
+                    orientation='h',
+                    title="Top 10 Processos por Número de Interações",
+                    color='total_interactions',
+                    color_continuous_scale="Blues",
+                    hover_data=['total_checklists']
+                )
+                st.plotly_chart(fig_active, use_container_width=True)
+            else:
+                st.info("Nenhum processo com interações disponível.")
+        
+        with col2:
+            # Atividade ao longo do tempo
+            st.markdown("#### ⏰ Atividade ao Longo do Tempo")
+            
+            df_interactions['data_primeira_interacao'] = pd.to_datetime(df_interactions['first_interaction']).dt.date
+            atividade_diaria = df_interactions.groupby('data_primeira_interacao').size().reset_index(name='checklists_iniciados')
+            
+            fig_atividade = px.line(
+                atividade_diaria,
+                x='data_primeira_interacao',
+                y='checklists_iniciados',
+                title="Checklists com Primeira Interação por Dia",
+                markers=True
+            )
+            st.plotly_chart(fig_atividade, use_container_width=True)
+    
+    # =================== RANKING DE PROCESSOS ===================
+    if not df_processes.empty:
+        st.markdown("---")
+        st.subheader("🏆 Ranking de Processos")
+        
+        col1, col2 = st.columns(2)
+        
+        with col1:
+            # Processos com maior progresso
+            st.markdown("#### 🥇 Processos com Maior Progresso")
+            
+            top_progress = df_processes.sort_values('avg_progress', ascending=False).head(5)
+            
+            for i, (idx, row) in enumerate(top_progress.iterrows()):
+                progress = row['avg_progress'] or 0
+                medal = "🥇" if i == 0 else "🥈" if i == 1 else "🥉" if i == 2 else "🏅"
+                st.write(f"{medal} **{row['numero_processo']}** - {progress:.1f}% ({row['total_checklists']} checklists)")
+        
+        with col2:
+            # Processos com mais checklists
+            st.markdown("#### 📊 Processos com Mais Checklists")
+            
+            top_volume = df_processes.sort_values('total_checklists', ascending=False).head(5)
+            
+            for i, (idx, row) in enumerate(top_volume.iterrows()):
+                progress = row['avg_progress'] or 0
+                medal = "🥇" if i == 0 else "🥈" if i == 1 else "🥉" if i == 2 else "🏅"
+                st.write(f"{medal} **{row['numero_processo']}** - {row['total_checklists']} checklists ({progress:.1f}% progresso)")
+    
+    # =================== TABELA DETALHADA ===================
+    st.markdown("---")
+    st.subheader("📋 Dados Detalhados")
+    
+    # Filtros
+    col1, col2, col3 = st.columns(3)
+    
+    with col1:
+        if not df_processes.empty:
+            processos_disponiveis = ['Todos'] + df_processes['numero_processo'].tolist()
+            processo_selecionado = st.selectbox(
+                "Filtrar por Processo:",
+                options=processos_disponiveis,
+                index=0
+            )
+        else:
+            processo_selecionado = 'Todos'
+    
+    with col2:
+        faixa_progresso_selecionada = st.selectbox(
+            "Filtrar por Progresso:",
+            options=['Todos', '0-25%', '26-50%', '51-75%', '76-100%'],
+            index=0
+        )
+    
+    with col3:
+        # Ordenação
+        ordenacao = st.selectbox(
+            "Ordenar por:",
+            options=['Data de Criação', 'Progresso', 'Nome', 'Número de Items'],
+            index=0
+        )
+    
+    # Aplicar filtros
+    df_filtrado = df_checklists.copy()
+    
+    if processo_selecionado != 'Todos':
+        df_filtrado = df_filtrado[df_filtrado['numero_processo'] == processo_selecionado]
+    
+    if faixa_progresso_selecionada != 'Todos':
+        df_filtrado = df_filtrado[df_filtrado['faixa_progresso'] == faixa_progresso_selecionada]
+    
+    # Aplicar ordenação
+    if ordenacao == 'Data de Criação':
+        df_filtrado = df_filtrado.sort_values('created_at', ascending=False)
+    elif ordenacao == 'Progresso':
+        df_filtrado = df_filtrado.sort_values('progress_percentage', ascending=False)
+    elif ordenacao == 'Nome':
+        df_filtrado = df_filtrado.sort_values('name')
+    elif ordenacao == 'Número de Items':
+        df_filtrado = df_filtrado.sort_values('total_items', ascending=False)
+    
+    # Mostrar tabela filtrada
+    if not df_filtrado.empty:
+        # Preparar dados para exibição
+        df_display = df_filtrado[['name', 'numero_processo', 'total_items', 'completed_items', 'progress_percentage', 'created_at']].copy()
+        df_display.columns = ['Nome', 'Processo', 'Total Items', 'Items Concluídos', 'Progresso (%)', 'Data Criação']
+        df_display['Data Criação'] = pd.to_datetime(df_display['Data Criação']).dt.strftime('%d/%m/%Y')
+        
+        st.dataframe(df_display, use_container_width=True)
+        
+        # Estatísticas dos dados filtrados
+        st.markdown("#### 📊 Estatísticas dos Dados Filtrados")
+        col1, col2, col3, col4 = st.columns(4)
+        
+        with col1:
+            st.metric("Checklists Filtrados", len(df_filtrado))
+        
+        with col2:
+            progresso_medio_filtrado = df_filtrado['progress_percentage'].mean()
+            st.metric("Progresso Médio", f"{progresso_medio_filtrado:.1f}%")
+        
+        with col3:
+            checklists_completos_filtrados = len(df_filtrado[df_filtrado['progress_percentage'] == 100])
+            st.metric("Checklists Completos", checklists_completos_filtrados)
+        
+        with col4:
+            total_items_filtrados = df_filtrado['total_items'].sum()
+            st.metric("Total de Items", total_items_filtrados)
+    else:
+        st.info("🔍 Nenhum checklist encontrado com os filtros aplicados.")
+
+# Rodapé
+st.markdown("---")
+st.markdown("📊 **Dashboard Geral de Checklists** | Atualizado automaticamente a cada 5 minutos")
+st.markdown("💡 *Dica: Use os filtros para análises mais específicas por processo ou faixa de progresso*")

pages/relatorio_ia.py

@@ -0,0 +1,325 @@
+"""Página de Relatórios com IA"""
+
+import streamlit as st
+import pandas as pd
+from datetime import datetime
+import os
+from io import BytesIO
+import plotly.express as px
+import plotly.graph_objects as go
+
+# Tentar importar dependências da IA
+try:
+    import openai
+    from reportlab.lib.pagesizes import letter, A4
+    from reportlab.platypus import SimpleDocTemplate, Paragraph, Spacer
+    from reportlab.lib.styles import getSampleStyleSheet, ParagraphStyle
+    from reportlab.lib.units import inch
+    from dotenv import load_dotenv
+    AI_AVAILABLE = True
+except ImportError:
+    AI_AVAILABLE = False
+
+from utils.database import get_comprehensive_analysis_data
+
+def load_prompts():
+    """Carrega os prompts dos arquivos"""
+    prompts = {}
+    
+    try:
+        with open('prompt_analise_checklists.txt', 'r', encoding='utf-8') as f:
+            prompts['analise'] = f.read()
+    except FileNotFoundError:
+        prompts['analise'] = "Analise os dados de checklists fornecidos e forneça insights sobre eficiência dos processos."
+    
+    try:
+        with open('prompt_relatorio_executivo.txt', 'r', encoding='utf-8') as f:
+            prompts['executivo'] = f.read()
+    except FileNotFoundError:
+        prompts['executivo'] = "Crie um relatório executivo baseado nos dados fornecidos."
+    
+    return prompts
+
+def setup_openai():
+    """Configura a API da OpenAI"""
+    # Tentar carregar .env se existir (desenvolvimento local)
+    try:
+        load_dotenv()
+    except:
+        pass
+    
+    # Priorizar variáveis de ambiente do sistema (Hugging Face Spaces)
+    api_key = os.getenv('OPENAI_API_KEY')
+    
+    if not api_key:
+        return False
+    
+    openai.api_key = api_key
+    return True
+
+def format_data_for_ai(data):
+    """Formata os dados para análise da IA"""
+    process_data = data['process_data']
+    global_stats = data['global_stats']
+    
+    # Formatação dos dados de processos
+    formatted_data = "=== DADOS DOS PROCESSOS ===\n\n"
+    
+    for process in process_data:
+        formatted_data += f"Processo: {process['numero_processo']}\n"
+        formatted_data += f"- Checklists: {process['total_checklists']}\n"
+        formatted_data += f"- Progresso médio: {process['avg_progress_percentage']}%\n"
+        formatted_data += f"- Total de itens: {process['total_items']}\n"
+        formatted_data += f"- Itens concluídos: {process['completed_items']}\n"
+        formatted_data += f"- Data de início: {process['process_start_date']}\n"
+        formatted_data += f"- Dias decorridos: {process['days_elapsed']}\n"
+        formatted_data += f"- Dias restantes para deadline: {process['days_remaining_to_deadline']}\n"
+        formatted_data += f"- Status do prazo: {process['status_prazo']}\n"
+        formatted_data += f"- Projeção para conclusão: {process['projected_days_to_complete']} dias\n"
+        formatted_data += f"- Total de interações: {process['total_interactions']}\n\n"
+    
+    # Estatísticas globais
+    formatted_data += "=== ESTATÍSTICAS GLOBAIS ===\n\n"
+    formatted_data += f"Total de checklists: {global_stats['total_checklists_global']}\n"
+    formatted_data += f"Total de processos: {global_stats['total_processes']}\n"
+    formatted_data += f"Total de itens: {global_stats['total_items_global']}\n"
+    formatted_data += f"Itens concluídos: {global_stats['completed_items_global']}\n"
+    formatted_data += f"Total de interações: {global_stats['total_interactions_global']}\n"
+    formatted_data += f"Primeiro processo: {global_stats['earliest_process']}\n"
+    formatted_data += f"Último processo: {global_stats['latest_process']}\n"
+    
+    return formatted_data
+
+def generate_ai_analysis(data, prompt_type="analise"):
+    """Gera análise usando OpenAI"""
+    if not AI_AVAILABLE:
+        return "❌ Bibliotecas de IA não estão instaladas. Execute: pip install openai python-dotenv"
+    
+    if not setup_openai():
+        return "❌ Chave da API OpenAI não configurada. Crie um arquivo .env com OPENAI_API_KEY=sua_chave"
+    
+    prompts = load_prompts()
+    system_prompt = prompts.get(prompt_type, "Analise os dados fornecidos.")
+    formatted_data = format_data_for_ai(data)
+    
+    try:
+        client = openai.OpenAI()
+        response = client.chat.completions.create(
+            model="gpt-4",
+            messages=[
+                {"role": "system", "content": system_prompt},
+                {"role": "user", "content": formatted_data}
+            ],
+            temperature=0.7,
+            max_tokens=2000
+        )
+        
+        return response.choices[0].message.content
+        
+    except Exception as e:
+        return f"❌ Erro ao gerar análise: {str(e)}"
+
+def create_pdf_report(analysis_text, report_type="Análise de Checklists"):
+    """Cria PDF do relatório"""
+    if not AI_AVAILABLE:
+        return None
+    
+    buffer = BytesIO()
+    doc = SimpleDocTemplate(buffer, pagesize=A4)
+    styles = getSampleStyleSheet()
+    
+    # Estilo customizado para título
+    title_style = ParagraphStyle(
+        'CustomTitle',
+        parent=styles['Heading1'],
+        fontSize=16,
+        alignment=1,  # Centralizado
+        spaceAfter=30,
+    )
+    
+    # Conteúdo do PDF
+    story = []
+    
+    # Título
+    title = Paragraph(f"{report_type}", title_style)
+    story.append(title)
+    
+    # Data
+    date_str = datetime.now().strftime("%d/%m/%Y às %H:%M")
+    date_para = Paragraph(f"Gerado em: {date_str}", styles['Normal'])
+    story.append(date_para)
+    story.append(Spacer(1, 20))
+    
+    # Conteúdo da análise
+    # Quebrar o texto em parágrafos
+    paragraphs = analysis_text.split('\n\n')
+    for para in paragraphs:
+        if para.strip():
+            # Verificar se é um título (começar com ##)
+            if para.strip().startswith('##'):
+                para_clean = para.replace('##', '').strip()
+                p = Paragraph(para_clean, styles['Heading2'])
+            elif para.strip().startswith('- '):
+                p = Paragraph(para.strip(), styles['Normal'])
+            else:
+                p = Paragraph(para.strip(), styles['Normal'])
+            story.append(p)
+            story.append(Spacer(1, 12))
+    
+    # Gerar PDF
+    doc.build(story)
+    buffer.seek(0)
+    
+    return buffer
+
+def show_data_overview(data):
+    """Mostra visão geral dos dados"""
+    process_data = data['process_data']
+    global_stats = data['global_stats']
+    
+    st.subheader("📊 Visão Geral dos Dados")
+    
+    col1, col2, col3, col4 = st.columns(4)
+    
+    with col1:
+        st.metric("Total de Processos", global_stats['total_processes'])
+    
+    with col2:
+        st.metric("Total de Checklists", global_stats['total_checklists_global'])
+    
+    with col3:
+        st.metric("Total de Itens", global_stats['total_items_global'])
+    
+    with col4:
+        if global_stats['total_items_global'] > 0:
+            completion_rate = (global_stats['completed_items_global'] / global_stats['total_items_global']) * 100
+            st.metric("Taxa de Conclusão", f"{completion_rate:.1f}%")
+        else:
+            st.metric("Taxa de Conclusão", "0%")
+    
+    # Status dos processos
+    if process_data:
+        st.subheader("🎯 Status dos Processos por Prazo")
+        
+        status_counts = {}
+        for process in process_data:
+            status = process['status_prazo']
+            status_counts[status] = status_counts.get(status, 0) + 1
+        
+        # Gráfico de pizza para status
+        fig = px.pie(
+            values=list(status_counts.values()),
+            names=list(status_counts.keys()),
+            title="Distribuição de Status dos Processos"
+        )
+        st.plotly_chart(fig, use_container_width=True)
+        
+        # Gráfico de progresso por processo
+        st.subheader("📈 Progresso por Processo")
+        
+        df_processes = pd.DataFrame(process_data)
+        if not df_processes.empty:
+            fig2 = px.bar(
+                df_processes,
+                x='numero_processo',
+                y='avg_progress_percentage',
+                title="Progresso Médio por Processo",
+                labels={'avg_progress_percentage': 'Progresso (%)', 'numero_processo': 'Número do Processo'}
+            )
+            fig2.update_layout(xaxis_tickangle=-45)
+            st.plotly_chart(fig2, use_container_width=True)
+
+def main():
+    st.title("🤖 Relatórios com Inteligência Artificial")
+    st.markdown("---")
+    
+    if not AI_AVAILABLE:
+        st.error("⚠️ **Dependências de IA não instaladas**")
+        st.markdown("""
+        Para usar esta funcionalidade, instale as dependências:
+        ```bash
+        pip install openai reportlab python-dotenv
+        ```
+        """)
+        return
+    
+    # Verificar se tem dados
+    try:
+        data = get_comprehensive_analysis_data()
+        if not data['process_data']:
+            st.warning("📋 Nenhum processo encontrado. Crie alguns checklists primeiro!")
+            return
+    except Exception as e:
+        st.error(f"❌ Erro ao carregar dados: {str(e)}")
+        return
+    
+    # Abas principais
+    tab1, tab2, tab3 = st.tabs(["📊 Dados", "🔍 Análise IA", "📋 Relatório Executivo"])
+    
+    with tab1:
+        show_data_overview(data)
+    
+    with tab2:
+        st.subheader("🔍 Análise Detalhada com IA")
+        st.markdown("Esta análise utiliza IA para identificar padrões, gargalos e oportunidades de melhoria.")
+        
+        if st.button("🚀 Gerar Análise com IA", use_container_width=True):
+            with st.spinner("🤖 IA analisando os dados..."):
+                analysis = generate_ai_analysis(data, "analise")
+                
+                st.markdown("### 📋 Resultado da Análise")
+                st.markdown(analysis)
+                
+                # Botão para download PDF
+                if "❌" not in analysis:
+                    pdf_buffer = create_pdf_report(analysis, "Análise Detalhada de Checklists")
+                    if pdf_buffer:
+                        st.download_button(
+                            label="📄 Download PDF da Análise",
+                            data=pdf_buffer,
+                            file_name=f"analise_checklists_{datetime.now().strftime('%Y%m%d_%H%M')}.pdf",
+                            mime="application/pdf",
+                            use_container_width=True
+                        )
+    
+    with tab3:
+        st.subheader("📋 Relatório Executivo")
+        st.markdown("Relatório estratégico para apresentação à alta gestão.")
+        
+        if st.button("📊 Gerar Relatório Executivo", use_container_width=True):
+            with st.spinner("📊 Gerando relatório executivo..."):
+                executive_report = generate_ai_analysis(data, "executivo")
+                
+                st.markdown("### 🎯 Relatório Executivo")
+                st.markdown(executive_report)
+                
+                # Botão para download PDF
+                if "❌" not in executive_report:
+                    pdf_buffer = create_pdf_report(executive_report, "Relatório Executivo - Checklists de Planejamento")
+                    if pdf_buffer:
+                        st.download_button(
+                            label="📄 Download PDF do Relatório",
+                            data=pdf_buffer,
+                            file_name=f"relatorio_executivo_{datetime.now().strftime('%Y%m%d_%H%M')}.pdf",
+                            mime="application/pdf",
+                            use_container_width=True
+                        )
+    
+    # Seção de configuração
+    st.markdown("---")
+    with st.expander("⚙️ Configuração da API"):
+        st.markdown("""
+        **Para usar a funcionalidade de IA:**
+        
+        1. Obtenha uma chave da API OpenAI em: https://platform.openai.com/api-keys
+        2. Crie um arquivo `.env` na pasta do projeto
+        3. Adicione a linha: `OPENAI_API_KEY=sua_chave_aqui`
+        
+        **Arquivo .env exemplo:**
+        ```
+        OPENAI_API_KEY=sk-proj-abcd1234...
+        ```
+        """)
+
+if __name__ == "__main__":
+    main()

prompt_analise_checklists.txt

@@ -0,0 +1,30 @@
+Você é um especialista em análise de processos de planejamento e gestão de projetos. Sua função é analisar dados de checklists de processos de planejamento e fornecer insights valiosos.
+
+CONTEXTO:
+- Os dados representam checklists de processos de planejamento
+- Cada processo tem um número identificador
+- Os checklists contêm items que podem estar concluídos ou pendentes
+- Há registros de interações (quando usuários marcam/desmarcam items)
+- O prazo ideal para conclusão de um processo é de 6 meses (180 dias)
+
+INSTRUÇÕES PARA ANÁLISE:
+1. Analise os padrões de conclusão dos checklists
+2. Identifique processos com alta eficiência vs baixa eficiência
+3. Examine o tempo médio gasto em cada processo
+4. Identifique gargalos e pontos de melhoria
+5. Analise a aderência aos prazos estabelecidos
+6. Forneça recomendações específicas e acionáveis
+
+FORMATO DA RESPOSTA:
+- Use linguagem profissional mas acessível
+- Organize em seções claras
+- Inclua métricas específicas quando possível
+- Destaque insights mais importantes
+- Termine com recomendações práticas
+
+FOQUE EM:
+- Eficiência dos processos
+- Cumprimento de prazos
+- Padrões de comportamento dos usuários
+- Oportunidades de melhoria
+- Riscos identificados

prompt_relatorio_executivo.txt

@@ -0,0 +1,48 @@
+Você é um consultor executivo especializado em processos de planejamento. Sua função é criar um relatório executivo completo e estratégico para a alta gestão.
+
+CONTEXTO:
+- Este relatório será apresentado para gestores seniores
+- Os dados são sobre checklists de processos de planejamento
+- O prazo ideal é de 6 meses por processo
+- O foco deve ser em decisões estratégicas e ações gerenciais
+
+INSTRUÇÕES:
+1. Crie um relatório executivo conciso mas completo
+2. Use linguagem executiva apropriada
+3. Inclua análise de riscos e oportunidades
+4. Forneça recomendações específicas com priorização
+5. Destaque métricas chave de performance (KPIs)
+6. Identifique necessidades de recursos ou ajustes
+
+ESTRUTURA OBRIGATÓRIA:
+## RESUMO EXECUTIVO
+- Principais descobertas em 3-4 pontos
+- Status geral dos processos
+
+## INDICADORES CHAVE
+- Métricas principais de performance
+- Comparação com metas estabelecidas
+
+## ANÁLISE DE RISCOS
+- Processos em risco de atraso
+- Impactos potenciais
+
+## OPORTUNIDADES DE MELHORIA
+- Pontos de otimização identificados
+- Benefícios esperados
+
+## RECOMENDAÇÕES ESTRATÉGICAS
+- Ações imediatas (próximos 30 dias)
+- Ações de médio prazo (próximos 3 meses)
+- Investimentos ou recursos necessários
+
+## CONCLUSÃO
+- Próximos passos
+- Expectativas de resultados
+
+DIRETRIZES:
+- Máximo 2 páginas quando impresso
+- Linguagem objetiva e direta
+- Foco em ação e resultados
+- Inclua números e percentuais específicos
+- Evite jargões técnicos desnecessários

requirements.txt

@@ -0,0 +1,9 @@
+streamlit==1.47.1
+psycopg2-binary==2.9.10
+plotly==6.2.0
+pandas==2.3.1
+matplotlib==3.10.5
+seaborn==0.13.2
+openai==1.98.0
+reportlab==4.4.3
+python-dotenv==1.1.1

setup_database.py

@@ -0,0 +1,28 @@
+"""Script para configurar o banco de dados"""
+
+from utils.database import test_connection, create_tables
+
+def main():
+    print("Testando conexão com o banco de dados...")
+    
+    if test_connection():
+        print("\nConexão bem-sucedida!")
+        print("\nCriando tabelas...")
+        
+        try:
+            create_tables()
+            print("\nBanco de dados configurado com sucesso!")
+            print("\nTabelas criadas:")
+            print("- checklists")
+            print("- checklist_items")
+            print("- item_interactions")
+            print("\nViews criadas:")
+            print("- current_item_states")
+            print("- item_time_analysis")
+        except Exception as e:
+            print(f"\nErro ao criar tabelas: {e}")
+    else:
+        print("\nFalha na conexão com o banco de dados.")
+
+if __name__ == "__main__":
+    main()

update_database.py

@@ -0,0 +1,41 @@
+"""Script para adicionar coluna numero_processo"""
+
+from utils.database import get_db_connection
+
+def add_numero_processo_column():
+    """Adiciona coluna numero_processo na tabela checklists"""
+    with open('/Users/abimaeltorcate/checklist/add_numero_processo.sql', 'r') as f:
+        sql_script = f.read()
+    
+    try:
+        with get_db_connection() as conn:
+            with conn.cursor() as cur:
+                # Executar cada comando separadamente
+                commands = sql_script.split(';')
+                for command in commands:
+                    command = command.strip()
+                    if command:
+                        print(f"Executando: {command[:50]}...")
+                        cur.execute(command)
+                
+                conn.commit()
+                print("✅ Coluna numero_processo adicionada com sucesso!")
+                
+                # Verificar se a coluna foi adicionada
+                cur.execute("""
+                    SELECT column_name, data_type, is_nullable
+                    FROM information_schema.columns 
+                    WHERE table_name = 'checklists' AND table_schema = 'public'
+                    ORDER BY ordinal_position
+                """)
+                
+                columns = cur.fetchall()
+                print("\n📋 Colunas da tabela checklists:")
+                for col in columns:
+                    print(f"  - {col[0]} ({col[1]}) - Nullable: {col[2]}")
+                
+    except Exception as e:
+        print(f"❌ Erro: {e}")
+
+if __name__ == "__main__":
+    add_numero_processo_column()

utils/database.py

@@ -0,0 +1,628 @@
+"""Módulo de conexão e operações com o banco de dados PostgreSQL"""
+
+import psycopg2
+from psycopg2.extras import RealDictCursor
+import uuid
+from datetime import datetime
+from contextlib import contextmanager
+import streamlit as st
+import os
+
+# Configurações do banco de dados
+# Prioriza variáveis de ambiente (Hugging Face Spaces) sobre valores hardcoded
+DB_CONFIG = {
+    'host': os.getenv('DB_HOST', '77.37.43.160'),
+    'port': int(os.getenv('DB_PORT', 5432)),
+    'database': os.getenv('DB_NAME', 'checklist'),
+    'user': os.getenv('DB_USER', 'abimael'),
+    'password': os.getenv('DB_PASSWORD', 'ctweek')
+}
+
+@contextmanager
+def get_db_connection():
+    """Context manager para conexão com o banco de dados"""
+    conn = None
+    try:
+        conn = psycopg2.connect(**DB_CONFIG)
+        yield conn
+    except Exception as e:
+        if conn:
+            conn.rollback()
+        raise e
+    finally:
+        if conn:
+            conn.close()
+
+def create_tables():
+    """Cria as tabelas do banco se não existirem"""
+    # SQL inline para evitar dependência de arquivo externo
+    sql_script = """
+    -- Criar tabela de checklists
+    CREATE TABLE IF NOT EXISTS checklists (
+        id VARCHAR(36) PRIMARY KEY,
+        name VARCHAR(255) NOT NULL,
+        numero_processo VARCHAR(100),
+        created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+    );
+
+    -- Criar tabela de itens do checklist
+    CREATE TABLE IF NOT EXISTS checklist_items (
+        id VARCHAR(36) PRIMARY KEY,
+        checklist_id VARCHAR(36) REFERENCES checklists(id) ON DELETE CASCADE,
+        text TEXT NOT NULL,
+        position INTEGER NOT NULL
+    );
+
+    -- Criar tabela de interações
+    CREATE TABLE IF NOT EXISTS item_interactions (
+        id SERIAL PRIMARY KEY,
+        item_id VARCHAR(36) REFERENCES checklist_items(id) ON DELETE CASCADE,
+        checklist_id VARCHAR(36) REFERENCES checklists(id) ON DELETE CASCADE,
+        action VARCHAR(20) NOT NULL,
+        timestamp TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+    );
+
+    -- Criar view para estados atuais dos itens
+    CREATE OR REPLACE VIEW current_item_states AS
+    WITH latest_interactions AS (
+        SELECT 
+            item_id,
+            action,
+            timestamp,
+            ROW_NUMBER() OVER (PARTITION BY item_id ORDER BY timestamp DESC) as rn
+        FROM item_interactions
+    )
+    SELECT 
+        item_id,
+        CASE WHEN action = 'checked' THEN true ELSE false END as is_checked
+    FROM latest_interactions
+    WHERE rn = 1;
+
+    -- Criar view para análise de tempo por item
+    CREATE OR REPLACE VIEW item_time_analysis AS
+    WITH item_sessions AS (
+        SELECT 
+            ii.item_id,
+            ci.text as item_text,
+            ci.position,
+            ci.checklist_id,
+            ii.timestamp,
+            ii.action,
+            LAG(ii.timestamp) OVER (
+                PARTITION BY ii.item_id 
+                ORDER BY ii.timestamp
+            ) as prev_timestamp,
+            LAG(ii.action) OVER (
+                PARTITION BY ii.item_id 
+                ORDER BY ii.timestamp
+            ) as prev_action
+        FROM item_interactions ii
+        JOIN checklist_items ci ON ii.item_id = ci.id
+        ORDER BY ii.item_id, ii.timestamp
+    ),
+    work_sessions AS (
+        SELECT 
+            item_id,
+            item_text,
+            position,
+            checklist_id,
+            CASE 
+                WHEN prev_action = 'unchecked' AND action = 'checked' AND prev_timestamp IS NOT NULL
+                THEN EXTRACT(EPOCH FROM (timestamp - prev_timestamp))
+                ELSE 0
+            END as session_seconds
+        FROM item_sessions
+        WHERE prev_timestamp IS NOT NULL
+    )
+    SELECT 
+        item_id,
+        item_text,
+        position,
+        checklist_id,
+        COUNT(CASE WHEN session_seconds > 0 THEN 1 END) as times_worked,
+        COALESCE(SUM(session_seconds), 0) as total_seconds_spent,
+        CASE 
+            WHEN COUNT(CASE WHEN session_seconds > 0 THEN 1 END) > 0
+            THEN COALESCE(SUM(session_seconds), 0) / COUNT(CASE WHEN session_seconds > 0 THEN 1 END)
+            ELSE 0
+        END as avg_seconds_per_completion
+    FROM work_sessions
+    GROUP BY item_id, item_text, position, checklist_id;
+    """
+    
+    with get_db_connection() as conn:
+        with conn.cursor() as cur:
+            cur.execute(sql_script)
+            conn.commit()
+    print("Tabelas criadas com sucesso!")
+
+def save_checklist(name, items, numero_processo=None):
+    """Salva um novo checklist no banco de dados"""
+    checklist_id = str(uuid.uuid4())
+    
+    with get_db_connection() as conn:
+        with conn.cursor() as cur:
+            # Inserir checklist
+            cur.execute("""
+                INSERT INTO checklists (id, name, numero_processo)
+                VALUES (%s, %s, %s)
+            """, (checklist_id, name, numero_processo))
+            
+            # Inserir items
+            for position, item_text in enumerate(items):
+                if item_text.strip():
+                    item_id = str(uuid.uuid4())
+                    cur.execute("""
+                        INSERT INTO checklist_items (id, checklist_id, text, position)
+                        VALUES (%s, %s, %s, %s)
+                    """, (item_id, checklist_id, item_text.strip(), position))
+            
+            conn.commit()
+    
+    return checklist_id
+
+def get_all_checklists():
+    """Retorna todos os checklists do banco"""
+    with get_db_connection() as conn:
+        with conn.cursor(cursor_factory=RealDictCursor) as cur:
+            cur.execute("""
+                SELECT id, name, numero_processo, created_at
+                FROM checklists
+                ORDER BY created_at DESC
+            """)
+            return cur.fetchall()
+
+def get_checklist_with_items(checklist_id):
+    """Retorna um checklist com seus itens e estados atuais"""
+    with get_db_connection() as conn:
+        with conn.cursor(cursor_factory=RealDictCursor) as cur:
+            # Buscar checklist
+            cur.execute("""
+                SELECT id, name, numero_processo, created_at
+                FROM checklists
+                WHERE id = %s
+            """, (checklist_id,))
+            checklist = cur.fetchone()
+            
+            if not checklist:
+                return None
+            
+            # Buscar items com estado atual
+            cur.execute("""
+                SELECT 
+                    ci.id,
+                    ci.text,
+                    ci.position,
+                    COALESCE(cis.is_checked, false) as is_checked
+                FROM checklist_items ci
+                LEFT JOIN current_item_states cis ON ci.id = cis.item_id
+                WHERE ci.checklist_id = %s
+                ORDER BY ci.position
+            """, (checklist_id,))
+            
+            checklist['items'] = cur.fetchall()
+            
+            return checklist
+
+def toggle_item(item_id, checklist_id, new_state):
+    """Registra a mudança de estado de um item"""
+    action = 'checked' if new_state else 'unchecked'
+    
+    with get_db_connection() as conn:
+        with conn.cursor() as cur:
+            cur.execute("""
+                INSERT INTO item_interactions (item_id, checklist_id, action)
+                VALUES (%s, %s, %s)
+            """, (item_id, checklist_id, action))
+            conn.commit()
+
+def get_checklist_analytics(checklist_id):
+    """Retorna análises de tempo do checklist"""
+    with get_db_connection() as conn:
+        with conn.cursor(cursor_factory=RealDictCursor) as cur:
+            # Estatísticas gerais
+            cur.execute("""
+                SELECT 
+                    COUNT(DISTINCT ci.id) as total_items,
+                    COUNT(DISTINCT CASE WHEN cis.is_checked THEN ci.id END) as completed_items,
+                    MIN(ii.timestamp) as first_interaction,
+                    MAX(ii.timestamp) as last_interaction
+                FROM checklist_items ci
+                LEFT JOIN current_item_states cis ON ci.id = cis.item_id
+                LEFT JOIN item_interactions ii ON ci.id = ii.item_id
+                WHERE ci.checklist_id = %s
+            """, (checklist_id,))
+            
+            stats = cur.fetchone()
+            
+            # Análise de tempo por item
+            cur.execute("""
+                SELECT 
+                    item_text,
+                    position,
+                    times_worked,
+                    total_seconds_spent,
+                    avg_seconds_per_completion
+                FROM item_time_analysis
+                WHERE checklist_id = %s
+                ORDER BY position
+            """, (checklist_id,))
+            
+            time_analysis = cur.fetchall()
+            
+            return {
+                'stats': stats,
+                'time_analysis': time_analysis
+            }
+
+def delete_checklist(checklist_id):
+    """Deleta um checklist e todos os seus dados relacionados"""
+    with get_db_connection() as conn:
+        with conn.cursor() as cur:
+            cur.execute("DELETE FROM checklists WHERE id = %s", (checklist_id,))
+            conn.commit()
+
+def get_all_checklists_with_stats():
+    """Retorna todos os checklists com estatísticas de progresso"""
+    with get_db_connection() as conn:
+        with conn.cursor(cursor_factory=RealDictCursor) as cur:
+            cur.execute("""
+                SELECT 
+                    c.id,
+                    c.name,
+                    c.numero_processo,
+                    c.created_at,
+                    COUNT(ci.id) as total_items,
+                    COUNT(CASE WHEN cis.is_checked THEN 1 END) as completed_items,
+                    CASE 
+                        WHEN COUNT(ci.id) > 0 THEN 
+                            ROUND((COUNT(CASE WHEN cis.is_checked THEN 1 END)::decimal / COUNT(ci.id)) * 100, 1)
+                        ELSE 0 
+                    END as progress_percentage
+                FROM checklists c
+                LEFT JOIN checklist_items ci ON c.id = ci.checklist_id
+                LEFT JOIN current_item_states cis ON ci.id = cis.item_id
+                GROUP BY c.id, c.name, c.numero_processo, c.created_at
+                ORDER BY c.created_at DESC
+            """)
+            return cur.fetchall()
+
+def get_general_stats():
+    """Retorna estatísticas gerais do sistema"""
+    with get_db_connection() as conn:
+        with conn.cursor(cursor_factory=RealDictCursor) as cur:
+            cur.execute("""
+                WITH checklist_progress AS (
+                    SELECT 
+                        c.id,
+                        c.numero_processo,
+                        c.created_at,
+                        COUNT(ci.id) as total_items,
+                        COUNT(CASE WHEN cis.is_checked THEN 1 END) as completed_items,
+                        CASE 
+                            WHEN COUNT(ci.id) > 0 THEN 
+                                ROUND((COUNT(CASE WHEN cis.is_checked THEN 1 END)::decimal / COUNT(ci.id)) * 100, 1)
+                            ELSE 0 
+                        END as progress_percentage
+                    FROM checklists c
+                    LEFT JOIN checklist_items ci ON c.id = ci.checklist_id
+                    LEFT JOIN current_item_states cis ON ci.id = cis.item_id
+                    GROUP BY c.id, c.numero_processo, c.created_at
+                )
+                SELECT 
+                    COUNT(*) as total_checklists,
+                    COUNT(DISTINCT numero_processo) as total_processos,
+                    SUM(total_items) as total_items,
+                    SUM(completed_items) as completed_items,
+                    COUNT(CASE WHEN progress_percentage = 100 THEN 1 END) as completed_checklists,
+                    MIN(created_at) as first_checklist_date,
+                    MAX(created_at) as last_checklist_date,
+                    ROUND(AVG(progress_percentage), 1) as avg_progress
+                FROM checklist_progress
+            """)
+            return cur.fetchone()
+
+def get_checklist_interactions_summary():
+    """Retorna resumo de interações por checklist"""
+    with get_db_connection() as conn:
+        with conn.cursor(cursor_factory=RealDictCursor) as cur:
+            cur.execute("""
+                SELECT 
+                    c.id,
+                    c.name,
+                    c.numero_processo,
+                    c.created_at,
+                    COUNT(ii.id) as total_interactions,
+                    COUNT(DISTINCT ii.item_id) as items_with_interactions,
+                    MIN(ii.timestamp) as first_interaction,
+                    MAX(ii.timestamp) as last_interaction
+                FROM checklists c
+                LEFT JOIN item_interactions ii ON c.id = ii.checklist_id
+                GROUP BY c.id, c.name, c.numero_processo, c.created_at
+                HAVING COUNT(ii.id) > 0
+                ORDER BY c.created_at DESC
+            """)
+            return cur.fetchall()
+
+def get_process_summary():
+    """Retorna resumo por número de processo"""
+    with get_db_connection() as conn:
+        with conn.cursor(cursor_factory=RealDictCursor) as cur:
+            cur.execute("""
+                WITH checklist_progress AS (
+                    SELECT 
+                        c.id,
+                        c.numero_processo,
+                        COUNT(ci.id) as total_items,
+                        COUNT(CASE WHEN cis.is_checked THEN 1 END) as completed_items,
+                        CASE 
+                            WHEN COUNT(ci.id) > 0 THEN 
+                                ROUND((COUNT(CASE WHEN cis.is_checked THEN 1 END)::decimal / COUNT(ci.id)) * 100, 1)
+                            ELSE 0 
+                        END as progress_percentage
+                    FROM checklists c
+                    LEFT JOIN checklist_items ci ON c.id = ci.checklist_id
+                    LEFT JOIN current_item_states cis ON ci.id = cis.item_id
+                    WHERE c.numero_processo IS NOT NULL
+                    GROUP BY c.id, c.numero_processo
+                )
+                SELECT 
+                    numero_processo,
+                    COUNT(*) as total_checklists,
+                    SUM(total_items) as total_items,
+                    SUM(completed_items) as completed_items,
+                    ROUND(AVG(progress_percentage), 1) as avg_progress
+                FROM checklist_progress
+                GROUP BY numero_processo
+                ORDER BY avg_progress DESC
+            """)
+            return cur.fetchall()
+
+def get_fastest_processes():
+    """Retorna os processos mais rápidos baseado no tempo médio de conclusão"""
+    with get_db_connection() as conn:
+        with conn.cursor(cursor_factory=RealDictCursor) as cur:
+            cur.execute("""
+                WITH checklist_completion_times AS (
+                    SELECT 
+                        c.id,
+                        c.numero_processo,
+                        c.name,
+                        c.created_at,
+                        MIN(ii.timestamp) as first_interaction,
+                        MAX(ii.timestamp) as last_interaction,
+                        COUNT(DISTINCT ci.id) as total_items,
+                        COUNT(DISTINCT CASE WHEN cis.is_checked THEN ci.id END) as completed_items,
+                        CASE 
+                            WHEN COUNT(ci.id) > 0 THEN 
+                                ROUND((COUNT(CASE WHEN cis.is_checked THEN 1 END)::decimal / COUNT(ci.id)) * 100, 1)
+                            ELSE 0 
+                        END as progress_percentage
+                    FROM checklists c
+                    LEFT JOIN checklist_items ci ON c.id = ci.checklist_id
+                    LEFT JOIN current_item_states cis ON ci.id = cis.item_id
+                    LEFT JOIN item_interactions ii ON c.id = ii.checklist_id
+                    WHERE c.numero_processo IS NOT NULL
+                    GROUP BY c.id, c.numero_processo, c.name, c.created_at
+                ),
+                process_times AS (
+                    SELECT 
+                        numero_processo,
+                        COUNT(*) as total_checklists,
+                        COUNT(CASE WHEN progress_percentage = 100 THEN 1 END) as completed_checklists,
+                        AVG(progress_percentage) as avg_progress,
+                        AVG(
+                            CASE 
+                                WHEN first_interaction IS NOT NULL AND last_interaction IS NOT NULL 
+                                THEN EXTRACT(EPOCH FROM (last_interaction - first_interaction)) / 3600.0 -- horas
+                                ELSE NULL 
+                            END
+                        ) as avg_completion_hours,
+                        AVG(
+                            CASE 
+                                WHEN first_interaction IS NOT NULL 
+                                THEN EXTRACT(EPOCH FROM (first_interaction - created_at)) / 3600.0 -- horas até primeira interação
+                                ELSE NULL 
+                            END
+                        ) as avg_start_hours
+                    FROM checklist_completion_times
+                    GROUP BY numero_processo
+                )
+                SELECT 
+                    numero_processo,
+                    total_checklists,
+                    completed_checklists,
+                    ROUND(avg_progress::numeric, 1) as avg_progress,
+                    ROUND(avg_completion_hours::numeric, 2) as avg_completion_hours,
+                    ROUND(avg_start_hours::numeric, 2) as avg_start_hours,
+                    ROUND((avg_completion_hours + avg_start_hours)::numeric, 2) as total_avg_time_hours
+                FROM process_times
+                WHERE avg_completion_hours IS NOT NULL 
+                   OR avg_start_hours IS NOT NULL
+                ORDER BY total_avg_time_hours ASC NULLS LAST
+                LIMIT 10
+            """)
+            return cur.fetchall()
+
+def get_process_deadline_analysis():
+    """Analisa prazos dos processos com deadline de 6 meses"""
+    with get_db_connection() as conn:
+        with conn.cursor(cursor_factory=RealDictCursor) as cur:
+            cur.execute("""
+                WITH process_progress AS (
+                    SELECT 
+                        c.numero_processo,
+                        c.created_at,
+                        COUNT(ci.id) as total_items,
+                        COUNT(CASE WHEN cis.is_checked THEN 1 END) as completed_items,
+                        CASE 
+                            WHEN COUNT(ci.id) > 0 THEN 
+                                ROUND((COUNT(CASE WHEN cis.is_checked THEN 1 END)::decimal / COUNT(ci.id)) * 100, 1)
+                            ELSE 0 
+                        END as progress_percentage,
+                        MIN(ii.timestamp) as first_interaction,
+                        MAX(ii.timestamp) as last_interaction,
+                        COUNT(DISTINCT c.id) as total_checklists
+                    FROM checklists c
+                    LEFT JOIN checklist_items ci ON c.id = ci.checklist_id
+                    LEFT JOIN current_item_states cis ON ci.id = cis.item_id
+                    LEFT JOIN item_interactions ii ON c.id = ii.checklist_id
+                    WHERE c.numero_processo IS NOT NULL
+                    GROUP BY c.numero_processo, c.created_at
+                ),
+                process_summary AS (
+                    SELECT 
+                        numero_processo,
+                        MIN(created_at) as process_start_date,
+                        MAX(created_at) as latest_checklist_date,
+                        SUM(total_items) as total_items,
+                        SUM(completed_items) as completed_items,
+                        ROUND(AVG(progress_percentage), 1) as avg_progress,
+                        MIN(first_interaction) as first_interaction,
+                        MAX(last_interaction) as last_interaction,
+                        SUM(total_checklists) as total_checklists
+                    FROM process_progress
+                    GROUP BY numero_processo
+                )
+                SELECT 
+                    numero_processo,
+                    process_start_date,
+                    latest_checklist_date,
+                    total_items,
+                    completed_items,
+                    avg_progress,
+                    first_interaction,
+                    last_interaction,
+                    total_checklists,
+                    -- Cálculos de prazo (6 meses = 180 dias)
+                    (process_start_date + INTERVAL '180 days')::date as deadline_date,
+                    CURRENT_DATE - process_start_date::date as days_elapsed,
+                    (process_start_date + INTERVAL '180 days')::date - CURRENT_DATE as days_remaining,
+                    -- Velocidade e projeção
+                    CASE 
+                        WHEN (CURRENT_DATE - process_start_date::date) > 0 AND avg_progress > 0 THEN
+                            ROUND((avg_progress / (CURRENT_DATE - process_start_date::date)) * 
+                                  (100 - avg_progress), 0)
+                        ELSE NULL
+                    END as projected_days_to_complete,
+                    -- Status do prazo
+                    CASE 
+                        WHEN avg_progress = 100 THEN 'CONCLUIDO'
+                        WHEN (CURRENT_DATE - process_start_date::date) > 180 THEN 'ATRASADO'
+                        WHEN (CURRENT_DATE - process_start_date::date) > 0 AND avg_progress > 0 THEN
+                            CASE 
+                                WHEN ((avg_progress / (CURRENT_DATE - process_start_date::date)) * 
+                                      (100 - avg_progress) + (CURRENT_DATE - process_start_date::date)) > 180 
+                                THEN 'RISCO_ATRASO'
+                                WHEN ((avg_progress / (CURRENT_DATE - process_start_date::date)) * 
+                                      (100 - avg_progress) + (CURRENT_DATE - process_start_date::date)) > 150 
+                                THEN 'EM_RISCO'
+                                ELSE 'NO_PRAZO'
+                            END
+                        ELSE 'SEM_DADOS'
+                    END as status_prazo
+                FROM process_summary
+                ORDER BY days_remaining ASC NULLS LAST
+            """)
+            return cur.fetchall()
+
+def get_comprehensive_analysis_data():
+    """Retorna dados completos para análise com IA"""
+    with get_db_connection() as conn:
+        with conn.cursor(cursor_factory=RealDictCursor) as cur:
+            # Dados gerais dos processos
+            cur.execute("""
+                WITH process_stats AS (
+                    SELECT 
+                        c.numero_processo,
+                        COUNT(DISTINCT c.id) as total_checklists,
+                        MIN(c.created_at) as process_start_date,
+                        MAX(c.created_at) as latest_checklist_date,
+                        COUNT(ci.id) as total_items,
+                        COUNT(CASE WHEN cis.is_checked THEN 1 END) as completed_items,
+                        ROUND(AVG(
+                            CASE 
+                                WHEN COUNT(ci.id) OVER (PARTITION BY c.id) > 0 THEN 
+                                    (COUNT(CASE WHEN cis.is_checked THEN 1 END) OVER (PARTITION BY c.id)::decimal / 
+                                     COUNT(ci.id) OVER (PARTITION BY c.id)) * 100
+                                ELSE 0 
+                            END
+                        ), 1) as avg_progress_percentage,
+                        COUNT(ii.id) as total_interactions,
+                        MIN(ii.timestamp) as first_interaction,
+                        MAX(ii.timestamp) as last_interaction,
+                        CURRENT_DATE - MIN(c.created_at)::date as days_elapsed,
+                        (MIN(c.created_at) + INTERVAL '180 days')::date - CURRENT_DATE as days_remaining_to_deadline
+                    FROM checklists c
+                    LEFT JOIN checklist_items ci ON c.id = ci.checklist_id
+                    LEFT JOIN current_item_states cis ON ci.id = cis.item_id
+                    LEFT JOIN item_interactions ii ON c.id = ii.checklist_id
+                    WHERE c.numero_processo IS NOT NULL
+                    GROUP BY c.numero_processo
+                )
+                SELECT 
+                    numero_processo,
+                    total_checklists,
+                    process_start_date,
+                    latest_checklist_date,
+                    total_items,
+                    completed_items,
+                    avg_progress_percentage,
+                    total_interactions,
+                    first_interaction,
+                    last_interaction,
+                    days_elapsed,
+                    days_remaining_to_deadline,
+                    CASE 
+                        WHEN avg_progress_percentage = 100 THEN 'CONCLUIDO'
+                        WHEN days_remaining_to_deadline < 0 THEN 'ATRASADO'
+                        WHEN days_remaining_to_deadline < 30 THEN 'EM_RISCO'
+                        ELSE 'NO_PRAZO'
+                    END as status_prazo,
+                    CASE 
+                        WHEN days_elapsed > 0 AND avg_progress_percentage > 0 THEN
+                            ROUND((avg_progress_percentage / days_elapsed) * (100 - avg_progress_percentage), 0)
+                        ELSE NULL
+                    END as projected_days_to_complete
+                FROM process_stats
+                ORDER BY days_remaining_to_deadline ASC
+            """)
+            
+            process_data = cur.fetchall()
+            
+            # Estatísticas globais
+            cur.execute("""
+                SELECT 
+                    COUNT(DISTINCT c.id) as total_checklists_global,
+                    COUNT(DISTINCT c.numero_processo) as total_processes,
+                    COUNT(ci.id) as total_items_global,
+                    COUNT(CASE WHEN cis.is_checked THEN 1 END) as completed_items_global,
+                    COUNT(ii.id) as total_interactions_global,
+                    MIN(c.created_at) as earliest_process,
+                    MAX(c.created_at) as latest_process
+                FROM checklists c
+                LEFT JOIN checklist_items ci ON c.id = ci.checklist_id
+                LEFT JOIN current_item_states cis ON ci.id = cis.item_id
+                LEFT JOIN item_interactions ii ON c.id = ii.checklist_id
+            """)
+            
+            global_stats = cur.fetchone()
+            
+            return {
+                'process_data': process_data,
+                'global_stats': global_stats
+            }
+
+# Função para testar conexão
+def test_connection():
+    """Testa a conexão com o banco de dados"""
+    try:
+        with get_db_connection() as conn:
+            with conn.cursor() as cur:
+                cur.execute("SELECT version()")
+                version = cur.fetchone()
+                print(f"Conectado ao PostgreSQL: {version[0]}")
+                return True
+    except Exception as e:
+        print(f"Erro ao conectar: {e}")
+        return False