bps-kit 1.0.1 → 1.0.2

package/templates/vault/context-agent/scripts/compressor.py

@@ -0,0 +1,149 @@
+"""
+Compressão inteligente e arquivamento de sessões antigas.
+Mantém o histórico enxuto sem perder informação crítica.
+"""
+
+import shutil
+from datetime import datetime
+from pathlib import Path
+
+from config import SESSIONS_DIR, ARCHIVE_DIR, ARCHIVE_AFTER_SESSIONS
+
+
+def should_archive(session_number: int, current_session: int) -> bool:
+    """Verifica se uma sessão deve ser arquivada."""
+    return (current_session - session_number) > ARCHIVE_AFTER_SESSIONS
+
+
+def archive_session(session_path: Path):
+    """Move sessão para archive/ com resumo compacto."""
+    ARCHIVE_DIR.mkdir(parents=True, exist_ok=True)
+
+    text = session_path.read_text(encoding="utf-8")
+    compressed = _compress_session(text)
+
+    archive_path = ARCHIVE_DIR / session_path.name
+    archive_path.write_text(compressed, encoding="utf-8")
+
+    session_path.unlink()
+
+
+def _compress_session(text: str) -> str:
+    """Comprime uma sessão mantendo apenas informação essencial."""
+    lines = text.splitlines()
+    compressed = []
+    keep_sections = {
+        "tópicos", "decisões", "tarefas pendentes",
+        "descobertas", "erros resolvidos", "convenções",
+    }
+    skip_sections = {
+        "métricas", "arquivos modificados", "dívida técnica",
+    }
+
+    current_section = ""
+    keeping = True
+
+    for line in lines:
+        # Sempre manter cabeçalho
+        if line.startswith("# Sessão"):
+            compressed.append(line)
+            compressed.append("")
+            continue
+
+        if line.startswith("## "):
+            section_name = line[3:].strip().lower()
+            if section_name in skip_sections:
+                keeping = False
+            elif section_name in keep_sections:
+                keeping = True
+                compressed.append(line)
+            else:
+                keeping = False
+            current_section = section_name
+            continue
+
+        if keeping and line.strip():
+            compressed.append(line)
+
+    compressed.append("")
+    compressed.append("*[Sessão arquivada — detalhes completos removidos]*")
+    return "\n".join(compressed)
+
+
+def compress_archive():
+    """Consolida arquivos antigos em ARCHIVE_YYYY.md."""
+    if not ARCHIVE_DIR.exists():
+        return
+
+    year = datetime.now().strftime("%Y")
+    archive_files = sorted(ARCHIVE_DIR.glob("session-*.md"))
+
+    if len(archive_files) < 5:
+        return  # Não vale consolidar com poucos arquivos
+
+    consolidated_path = ARCHIVE_DIR / f"ARCHIVE_{year}.md"
+    consolidated_lines = [
+        f"# Arquivo Consolidado — {year}",
+        "",
+    ]
+
+    for af in archive_files:
+        text = af.read_text(encoding="utf-8")
+        # Extrair apenas título e decisões
+        session_header = ""
+        decisions = []
+        in_decisions = False
+
+        for line in text.splitlines():
+            if line.startswith("# Sessão"):
+                session_header = line
+            elif line.startswith("## Decisões"):
+                in_decisions = True
+            elif line.startswith("## "):
+                in_decisions = False
+            elif in_decisions and line.strip().startswith("- "):
+                decisions.append(line.strip())
+
+        if session_header:
+            consolidated_lines.append(f"### {session_header.lstrip('#').strip()}")
+            for d in decisions:
+                consolidated_lines.append(f"  {d}")
+            consolidated_lines.append("")
+
+        af.unlink()
+
+    consolidated_path.write_text("\n".join(consolidated_lines), encoding="utf-8")
+
+
+def auto_maintain(current_session: int):
+    """Executa arquivamento e compressão automáticos."""
+    if not SESSIONS_DIR.exists():
+        return
+
+    # Arquivar sessões antigas
+    for session_file in sorted(SESSIONS_DIR.glob("session-*.md")):
+        try:
+            num = int(session_file.stem.split("-")[1])
+        except (IndexError, ValueError):
+            continue
+
+        if should_archive(num, current_session):
+            archive_session(session_file)
+
+    # Consolidar arquivo se necessário
+    compress_archive()
+
+
+def get_archive_summary() -> str:
+    """Retorna resumo do que está arquivado."""
+    if not ARCHIVE_DIR.exists():
+        return "Nenhuma sessão arquivada."
+
+    archive_files = list(ARCHIVE_DIR.glob("*.md"))
+    if not archive_files:
+        return "Nenhuma sessão arquivada."
+
+    lines = [f"Sessões arquivadas: {len(archive_files)} arquivo(s)"]
+    for af in sorted(archive_files):
+        lines.append(f"  - {af.name}")
+    return "\n".join(lines)

package/templates/vault/context-agent/scripts/config.py

@@ -0,0 +1,69 @@
+"""
+Configuração centralizada do Context Agent.
+Todos os paths, constantes e limites usados pelos demais módulos.
+"""
+
+from pathlib import Path
+
+# ── Raízes ──────────────────────────────────────────────────────────
+SKILLS_ROOT = Path(r"C:\Users\renat\skills")
+CONTEXT_AGENT_ROOT = SKILLS_ROOT / "context-agent"
+
+# ── Dados do agente ─────────────────────────────────────────────────
+DATA_DIR = CONTEXT_AGENT_ROOT / "data"
+SESSIONS_DIR = DATA_DIR / "sessions"
+ARCHIVE_DIR = DATA_DIR / "archive"
+LOGS_DIR = DATA_DIR / "logs"
+ACTIVE_CONTEXT_PATH = DATA_DIR / "ACTIVE_CONTEXT.md"
+PROJECT_REGISTRY_PATH = DATA_DIR / "PROJECT_REGISTRY.md"
+DB_PATH = DATA_DIR / "context.db"
+
+# ── Claude Code session logs ────────────────────────────────────────
+CLAUDE_PROJECTS_DIR = Path(r"C:\Users\renat\.claude\projects")
+CLAUDE_SESSION_DIR = CLAUDE_PROJECTS_DIR / "C--Users-renat-skills"
+MEMORY_DIR = CLAUDE_SESSION_DIR / "memory"
+MEMORY_MD_PATH = MEMORY_DIR / "MEMORY.md"
+
+# ── Limites ─────────────────────────────────────────────────────────
+MAX_ACTIVE_CONTEXT_LINES = 150      # MEMORY.md é truncado em 200 linhas
+MAX_RECENT_SESSIONS = 5             # Sessões recentes carregadas no briefing
+ARCHIVE_AFTER_SESSIONS = 20         # Arquivar sessões mais antigas que N
+MAX_DECISIONS_AGE_DAYS = 30         # Decisões mais velhas são podadas
+MAX_SEARCH_RESULTS = 10             # Resultados padrão de busca
+
+# ── Padrões de detecção ────────────────────────────────────────────
+# Palavras que indicam decisões no texto
+DECISION_MARKERS_PT = [
+    "decidimos", "vamos usar", "optamos por", "escolhemos",
+    "a decisão foi", "ficou decidido", "definimos que",
+    "a abordagem será", "seguiremos com",
+]
+DECISION_MARKERS_EN = [
+    "we decided", "let's use", "we'll go with", "the decision is",
+    "we chose", "going with", "the approach will be", "decided to",
+]
+DECISION_MARKERS = DECISION_MARKERS_PT + DECISION_MARKERS_EN
+
+# Palavras que indicam tarefas pendentes
+PENDING_MARKERS_PT = [
+    "falta", "ainda precisa", "pendente", "todo:", "TODO:",
+    "depois vamos", "próximo passo", "faltando",
+]
+PENDING_MARKERS_EN = [
+    "todo:", "TODO:", "still need", "pending", "next step",
+    "remaining", "left to do", "needs to be done",
+]
+PENDING_MARKERS = PENDING_MARKERS_PT + PENDING_MARKERS_EN
+
+# Ferramentas que modificam arquivos (para detectar files_modified)
+FILE_MODIFYING_TOOLS = {"Edit", "Write", "NotebookEdit"}
+FILE_READING_TOOLS = {"Read", "Glob", "Grep"}
+
+# ── Projetos conhecidos ────────────────────────────────────────────
+# Mapeamento de subdiretórios de SKILLS_ROOT para nomes de projeto
+KNOWN_PROJECTS = {
+    "instagram": "Instagram Integration",
+    "juntas-comerciais": "Juntas Comerciais Scraper",
+    "whatsapp-cloud-api": "WhatsApp Cloud API",
+    "context-agent": "Context Agent",
+}

package/templates/vault/context-agent/scripts/context_loader.py

@@ -0,0 +1,155 @@
+"""
+Carrega contexto no início de uma nova sessão.
+Gera briefings de diferentes níveis de detalhe.
+"""
+
+from pathlib import Path
+
+from config import SESSIONS_DIR, MAX_RECENT_SESSIONS
+from models import SessionSummary
+from active_context import load_active_context, ACTIVE_CONTEXT_PATH
+from project_registry import load_registry, PROJECT_REGISTRY_PATH
+from compressor import get_archive_summary
+
+
+def generate_briefing() -> str:
+    """Gera briefing completo para início de sessão."""
+    sections = []
+
+    # 1. Cabeçalho
+    sections.append("# Briefing de Contexto")
+    sections.append("")
+
+    # 2. Contexto ativo
+    ctx = load_active_context()
+    if ctx.recent_sessions:
+        sections.append(f"**Total de sessões registradas:** {ctx.total_sessions}")
+        sections.append("")
+
+    # 3. Projetos ativos
+    projects = load_registry()
+    active_projects = [p for p in projects if p.status == "active"]
+    if active_projects:
+        sections.append("## Projetos Ativos")
+        for p in active_projects:
+            session_ref = f"session-{p.last_session:03d}" if p.last_session else "—"
+            actions = "; ".join(p.next_actions) if p.next_actions else "nenhuma definida"
+            sections.append(f"- **{p.name}** ({p.status}) — última: {session_ref} — próxima: {actions}")
+        sections.append("")
+
+    # 4. Tarefas pendentes de alta prioridade
+    high_tasks = [t for t in ctx.pending_tasks if t.priority == "high"]
+    if high_tasks:
+        sections.append("## Tarefas Pendentes (Alta Prioridade)")
+        for t in high_tasks:
+            src = f" (desde session-{t.source_session:03d})" if t.source_session else ""
+            sections.append(f"- {t.description}{src}")
+        sections.append("")
+
+    # 5. Todas as tarefas pendentes
+    other_tasks = [t for t in ctx.pending_tasks if t.priority != "high"]
+    if other_tasks:
+        sections.append("## Outras Tarefas Pendentes")
+        for t in other_tasks[:10]:
+            sections.append(f"- [{t.priority}] {t.description}")
+        sections.append("")
+
+    # 6. Bloqueadores
+    if ctx.active_blockers:
+        sections.append("## Bloqueadores Ativos")
+        for b in ctx.active_blockers:
+            sections.append(f"- {b}")
+        sections.append("")
+
+    # 7. Decisões recentes
+    if ctx.recent_decisions:
+        sections.append("## Decisões Recentes")
+        for d in ctx.recent_decisions[-10:]:
+            sections.append(f"- {d}")
+        sections.append("")
+
+    # 8. Convenções
+    if ctx.conventions:
+        sections.append("## Convenções do Projeto")
+        for c in ctx.conventions:
+            sections.append(f"- {c}")
+        sections.append("")
+
+    # 9. Últimas sessões (resumo)
+    recent_files = _get_recent_session_files(MAX_RECENT_SESSIONS)
+    if recent_files:
+        sections.append("## Resumo das Últimas Sessões")
+        for sf in recent_files:
+            snippet = _get_session_snippet(sf)
+            sections.append(snippet)
+        sections.append("")
+
+    # 10. Arquivo
+    archive_info = get_archive_summary()
+    if "Nenhuma" not in archive_info:
+        sections.append("## Arquivo")
+        sections.append(archive_info)
+        sections.append("")
+
+    return "\n".join(sections)
+
+
+def get_quick_status() -> str:
+    """Versão curta: projetos + pendências críticas."""
+    lines = ["## Status Rápido", ""]
+
+    projects = load_registry()
+    active = [p for p in projects if p.status == "active"]
+    if active:
+        lines.append("**Projetos:** " + ", ".join(p.name for p in active))
+
+    ctx = load_active_context()
+    high = [t for t in ctx.pending_tasks if t.priority == "high"]
+    if high:
+        lines.append(f"**Pendências críticas:** {len(high)}")
+        for t in high[:3]:
+            lines.append(f"  - {t.description}")
+
+    total_pending = len(ctx.pending_tasks)
+    if total_pending:
+        lines.append(f"**Total de pendências:** {total_pending}")
+
+    if ctx.active_blockers:
+        lines.append(f"**Bloqueadores:** {len(ctx.active_blockers)}")
+
+    if ctx.recent_sessions:
+        lines.append(f"**Última sessão:** {ctx.recent_sessions[-1]}")
+
+    return "\n".join(lines)
+
+
+def _get_recent_session_files(n: int) -> list[Path]:
+    """Retorna os N arquivos de sessão mais recentes."""
+    if not SESSIONS_DIR.exists():
+        return []
+    files = sorted(SESSIONS_DIR.glob("session-*.md"), reverse=True)
+    return files[:n]
+
+
+def _get_session_snippet(session_path: Path) -> str:
+    """Extrai um resumo curto de um arquivo de sessão."""
+    text = session_path.read_text(encoding="utf-8")
+    lines = text.splitlines()
+
+    # Extrair cabeçalho e tópicos
+    header = ""
+    topics = []
+    in_topics = False
+
+    for line in lines:
+        if line.startswith("# Sessão"):
+            header = line.lstrip("#").strip()
+        elif line.startswith("## Tópicos"):
+            in_topics = True
+        elif line.startswith("## ") and in_topics:
+            break
+        elif in_topics and line.strip().startswith("- "):
+            topics.append(line.strip()[2:])
+
+    topic_str = "; ".join(topics[:3]) if topics else "sem tópicos registrados"
+    return f"- **{header}**: {topic_str}"

package/templates/vault/context-agent/scripts/context_manager.py

@@ -0,0 +1,302 @@
+#!/usr/bin/env python3
+"""
+Context Manager — Entry point CLI do Context Agent.
+Orquestra save, load, status, search, archive e maintain.
+
+Uso:
+  python context_manager.py init              # Bootstrap do sistema
+  python context_manager.py save [--session PATH]  # Salvar contexto da sessão
+  python context_manager.py load              # Carregar contexto (briefing)
+  python context_manager.py status            # Status rápido
+  python context_manager.py search QUERY      # Buscar no histórico
+  python context_manager.py briefing          # Briefing completo
+  python context_manager.py archive           # Arquivar sessões antigas
+  python context_manager.py maintain          # Auto-manutenção
+"""
+
+import argparse
+import io
+import sys
+from pathlib import Path
+
+# Fix Windows console encoding for Unicode output
+if sys.stdout.encoding != "utf-8":
+    sys.stdout = io.TextIOWrapper(sys.stdout.buffer, encoding="utf-8", errors="replace")
+if sys.stderr.encoding != "utf-8":
+    sys.stderr = io.TextIOWrapper(sys.stderr.buffer, encoding="utf-8", errors="replace")
+
+# Adicionar diretório dos scripts ao path
+sys.path.insert(0, str(Path(__file__).parent))
+
+from config import (
+    DATA_DIR, SESSIONS_DIR, ARCHIVE_DIR, LOGS_DIR,
+    ACTIVE_CONTEXT_PATH, PROJECT_REGISTRY_PATH,
+)
+from session_parser import (
+    parse_session_file, get_latest_session_file, get_session_metadata,
+    extract_files_modified, extract_tool_calls,
+)
+from session_summary import (
+    generate_summary, save_session_summary, get_next_session_number,
+)
+from active_context import (
+    load_active_context, update_active_context,
+    save_active_context, sync_to_memory, check_drift,
+)
+from project_registry import (
+    load_registry, save_registry, detect_projects_from_session, update_project,
+)
+from compressor import auto_maintain as compress_maintain
+from context_loader import generate_briefing, get_quick_status
+from search import init_search_db, index_session, search as fts_search, reindex_all
+
+
+def cmd_init(args):
+    """Bootstrap: cria diretórios e arquivos iniciais."""
+    dirs = [DATA_DIR, SESSIONS_DIR, ARCHIVE_DIR, LOGS_DIR]
+    for d in dirs:
+        d.mkdir(parents=True, exist_ok=True)
+
+    # Inicializar banco de busca
+    init_search_db()
+
+    # Criar ACTIVE_CONTEXT.md se não existir
+    if not ACTIVE_CONTEXT_PATH.exists():
+        ctx = load_active_context()
+        projects = load_registry()
+        save_active_context(ctx, projects)
+
+    # Criar PROJECT_REGISTRY.md se não existir
+    if not PROJECT_REGISTRY_PATH.exists():
+        projects = load_registry()
+        save_registry(projects)
+
+    # Sincronizar com MEMORY.md
+    sync_to_memory()
+
+    print("Context Agent inicializado com sucesso!")
+    print(f"  Diretório de dados: {DATA_DIR}")
+    print(f"  Sessões: {SESSIONS_DIR}")
+    print(f"  Arquivo: {ARCHIVE_DIR}")
+    print(f"  Contexto ativo: {ACTIVE_CONTEXT_PATH}")
+    print(f"  Registro de projetos: {PROJECT_REGISTRY_PATH}")
+
+
+def cmd_save(args):
+    """Salva contexto da sessão atual."""
+    # Encontrar arquivo de sessão
+    if args.session:
+        session_path = Path(args.session)
+    else:
+        session_path = get_latest_session_file()
+
+    if not session_path or not session_path.exists():
+        print("Nenhum arquivo de sessão encontrado.")
+        sys.exit(1)
+
+    print(f"Processando sessão: {session_path.name}")
+
+    # 1. Parse da sessão
+    entries = parse_session_file(session_path)
+    if not entries:
+        print("Sessão vazia — nada para salvar.")
+        return
+
+    metadata = get_session_metadata(entries)
+    session_number = get_next_session_number()
+
+    print(f"  Sessão #{session_number:03d} — {metadata.get('slug', '?')}")
+    print(f"  {metadata.get('message_count', 0)} mensagens, {metadata.get('tool_call_count', 0)} tool calls")
+
+    # 2. Gerar resumo
+    summary = generate_summary(entries, session_number, metadata)
+
+    # 3. Detectar projetos tocados
+    files_mod = extract_files_modified(entries)
+    tool_calls = extract_tool_calls(entries)
+    projects_touched = detect_projects_from_session(files_mod, tool_calls)
+    summary.projects_touched = projects_touched
+
+    # 4. Salvar resumo da sessão
+    path = save_session_summary(summary)
+    print(f"  Resumo salvo: {path}")
+
+    # 5. Atualizar registro de projetos
+    projects = load_registry()
+    for pname in projects_touched:
+        projects = update_project(
+            projects, pname,
+            last_touched=summary.date,
+            last_session=session_number,
+            status="active",
+        )
+    save_registry(projects)
+
+    # 6. Atualizar contexto ativo
+    ctx = load_active_context()
+    ctx = update_active_context(ctx, summary)
+    save_active_context(ctx, projects)
+
+    # 7. Sincronizar com MEMORY.md
+    sync_to_memory()
+    print("  MEMORY.md sincronizado")
+
+    # 8. Indexar para busca
+    init_search_db()
+    sections = {
+        "topics": "\n".join(summary.topics),
+        "decisions": "\n".join(summary.decisions),
+        "tasks_completed": "\n".join(summary.tasks_completed),
+        "tasks_pending": "\n".join(
+            t.description if hasattr(t, 'description') else str(t)
+            for t in summary.tasks_pending
+        ),
+        "files_modified": "\n".join(f["path"] for f in summary.files_modified),
+        "key_findings": "\n".join(summary.key_findings),
+        "errors": "\n".join(e["error"] for e in summary.errors_resolved),
+    }
+    index_session(session_number, summary.date, sections)
+    print("  Índice de busca atualizado")
+
+    print(f"\nContexto da sessão {session_number:03d} salvo com sucesso!")
+    print(f"  Tópicos: {len(summary.topics)}")
+    print(f"  Decisões: {len(summary.decisions)}")
+    print(f"  Tarefas completadas: {len(summary.tasks_completed)}")
+    print(f"  Tarefas pendentes: {len(summary.tasks_pending)}")
+    print(f"  Arquivos modificados: {len(summary.files_modified)}")
+
+
+def cmd_load(args):
+    """Carrega contexto — briefing completo."""
+    briefing = generate_briefing()
+    print(briefing)
+
+
+def cmd_status(args):
+    """Status rápido."""
+    status = get_quick_status()
+    print(status)
+
+    # Verificar drift
+    if check_drift():
+        print("\n⚠ ACTIVE_CONTEXT.md e MEMORY.md estão dessincronizados.")
+        print("  Execute: python context_manager.py maintain")
+
+
+def cmd_search(args):
+    """Busca no histórico."""
+    query = " ".join(args.query)
+    if not query:
+        print("Forneça um termo de busca.")
+        sys.exit(1)
+
+    init_search_db()
+    results = fts_search(query)
+
+    if not results:
+        print(f"Nenhum resultado para: {query}")
+        return
+
+    print(f"Resultados para '{query}':")
+    print()
+    for r in results:
+        print(f"  [session-{r.session_number:03d}] ({r.date}) [{r.section}]")
+        print(f"    {r.snippet}")
+        print()
+
+
+def cmd_briefing(args):
+    """Briefing detalhado."""
+    briefing = generate_briefing()
+    print(briefing)
+
+
+def cmd_archive(args):
+    """Arquivar sessões antigas."""
+    from session_summary import get_next_session_number
+    current = get_next_session_number() - 1
+    if current <= 0:
+        print("Nenhuma sessão para arquivar.")
+        return
+
+    compress_maintain(current)
+    print(f"Manutenção concluída. Sessão mais recente: {current:03d}")
+
+
+def cmd_maintain(args):
+    """Auto-manutenção: arquivar, comprimir, sincronizar."""
+    from session_summary import get_next_session_number
+    current = get_next_session_number() - 1
+
+    # 1. Arquivar sessões antigas
+    if current > 0:
+        compress_maintain(current)
+        print("Sessões antigas arquivadas.")
+
+    # 2. Verificar e corrigir drift
+    if check_drift():
+        sync_to_memory()
+        print("MEMORY.md ressincronizado.")
+
+    # 3. Reindexar busca
+    init_search_db()
+    reindex_all(SESSIONS_DIR)
+    print("Índice de busca reconstruído.")
+
+    print("\nManutenção concluída.")
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        description="Context Agent — Gerenciamento de contexto entre sessões",
+    )
+    subparsers = parser.add_subparsers(dest="command", help="Comando")
+
+    # init
+    subparsers.add_parser("init", help="Bootstrap do sistema")
+
+    # save
+    save_parser = subparsers.add_parser("save", help="Salvar contexto da sessão")
+    save_parser.add_argument("--session", help="Path para arquivo JSONL específico")
+
+    # load
+    subparsers.add_parser("load", help="Carregar contexto (briefing)")
+
+    # status
+    subparsers.add_parser("status", help="Status rápido")
+
+    # search
+    search_parser = subparsers.add_parser("search", help="Buscar no histórico")
+    search_parser.add_argument("query", nargs="+", help="Termo de busca")
+
+    # briefing
+    subparsers.add_parser("briefing", help="Briefing completo")
+
+    # archive
+    subparsers.add_parser("archive", help="Arquivar sessões antigas")
+
+    # maintain
+    subparsers.add_parser("maintain", help="Auto-manutenção")
+
+    args = parser.parse_args()
+
+    if not args.command:
+        parser.print_help()
+        sys.exit(0)
+
+    commands = {
+        "init": cmd_init,
+        "save": cmd_save,
+        "load": cmd_load,
+        "status": cmd_status,
+        "search": cmd_search,
+        "briefing": cmd_briefing,
+        "archive": cmd_archive,
+        "maintain": cmd_maintain,
+    }
+
+    commands[args.command](args)
+
+
+if __name__ == "__main__":
+    main()