bps-kit 1.0.1 → 1.0.2

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

@@ -0,0 +1,103 @@
+"""
+Modelos de dados do Context Agent.
+Dataclasses puras sem dependências externas.
+"""
+
+from dataclasses import dataclass, field
+from datetime import datetime
+from typing import Optional
+
+
+@dataclass
+class SessionEntry:
+    """Uma entrada individual do log JSONL do Claude Code."""
+    type: str                          # "user" | "assistant" | "queue-operation"
+    timestamp: str                     # ISO 8601
+    session_id: str
+    slug: str = ""
+    role: str = ""                     # "user" | "assistant"
+    content: str = ""                  # Texto da mensagem
+    tool_calls: list = field(default_factory=list)   # [{name, input}]
+    token_usage: dict = field(default_factory=dict)  # {input, output, cache_read}
+    model: str = ""
+    files_modified: list = field(default_factory=list)
+
+
+@dataclass
+class PendingTask:
+    """Tarefa pendente identificada em uma sessão."""
+    description: str
+    priority: str = "medium"           # "high" | "medium" | "low"
+    source_session: int = 0            # Número da sessão onde foi criada
+    created_date: str = ""
+    context: str = ""                  # Contexto adicional sobre a tarefa
+    completed: bool = False
+
+
+@dataclass
+class ProjectInfo:
+    """Informações de um projeto/skill rastreado."""
+    name: str
+    path: str = ""
+    status: str = "active"             # "active" | "paused" | "completed"
+    last_touched: str = ""             # Data da última interação
+    last_session: int = 0              # Número da última sessão
+    next_actions: list = field(default_factory=list)
+    dependencies: list = field(default_factory=list)
+
+
+@dataclass
+class SessionSummary:
+    """Resumo estruturado de uma sessão do Claude Code."""
+    session_number: int
+    session_id: str = ""
+    slug: str = ""
+    date: str = ""                     # YYYY-MM-DD
+    start_time: str = ""               # HH:MM
+    end_time: str = ""                 # HH:MM
+    duration_minutes: int = 0
+    model: str = ""
+
+    # Conteúdo
+    topics: list = field(default_factory=list)
+    decisions: list = field(default_factory=list)
+    tasks_completed: list = field(default_factory=list)
+    tasks_pending: list = field(default_factory=list)       # list[PendingTask]
+    files_modified: list = field(default_factory=list)      # list[{path, action}]
+    key_findings: list = field(default_factory=list)
+    errors_resolved: list = field(default_factory=list)     # list[{error, solution}]
+    open_questions: list = field(default_factory=list)
+    technical_debt: list = field(default_factory=list)
+
+    # Métricas
+    total_input_tokens: int = 0
+    total_output_tokens: int = 0
+    total_cache_tokens: int = 0
+    message_count: int = 0
+    tool_call_count: int = 0
+
+    # Projetos tocados nesta sessão
+    projects_touched: list = field(default_factory=list)
+
+
+@dataclass
+class ActiveContext:
+    """Contexto ativo consolidado de todas as sessões."""
+    last_updated: str = ""
+    projects: list = field(default_factory=list)             # list[ProjectInfo]
+    pending_tasks: list = field(default_factory=list)        # list[PendingTask]
+    recent_decisions: list = field(default_factory=list)     # list[{session, text}]
+    active_blockers: list = field(default_factory=list)
+    conventions: list = field(default_factory=list)
+    recent_sessions: list = field(default_factory=list)      # list[{number, summary}]
+    total_sessions: int = 0
+
+
+@dataclass
+class SearchResult:
+    """Resultado de busca no histórico de sessões."""
+    session_number: int
+    date: str
+    snippet: str
+    section: str                       # Em qual seção foi encontrado
+    relevance: float = 0.0

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

@@ -0,0 +1,132 @@
+"""
+Registro e tracking de projetos/skills.
+Mantém PROJECT_REGISTRY.md atualizado.
+"""
+
+import re
+from datetime import datetime
+from pathlib import Path
+
+from config import (
+    PROJECT_REGISTRY_PATH,
+    SKILLS_ROOT,
+    KNOWN_PROJECTS,
+)
+from models import ProjectInfo
+
+
+def load_registry() -> list[ProjectInfo]:
+    """Carrega projetos do PROJECT_REGISTRY.md."""
+    if not PROJECT_REGISTRY_PATH.exists():
+        return _discover_projects()
+
+    text = PROJECT_REGISTRY_PATH.read_text(encoding="utf-8")
+    projects = []
+    in_table = False
+
+    for line in text.splitlines():
+        if line.startswith("|") and "Projeto" in line:
+            in_table = True
+            continue
+        if in_table and line.startswith("|---"):
+            continue
+        if in_table and line.startswith("|"):
+            cells = [c.strip() for c in line.split("|")[1:-1]]
+            if len(cells) >= 4:
+                projects.append(ProjectInfo(
+                    name=cells[0],
+                    path=cells[1] if len(cells) > 4 else "",
+                    status=cells[2] if len(cells) > 4 else cells[1],
+                    last_touched=cells[3] if len(cells) > 4 else cells[2],
+                    last_session=_extract_session_number(cells[-1]) if cells[-1] else 0,
+                    next_actions=[a.strip() for a in (cells[4] if len(cells) > 4 else cells[3]).split(";") if a.strip()],
+                ))
+        elif in_table and not line.strip():
+            in_table = False
+
+    return projects if projects else _discover_projects()
+
+
+def _extract_session_number(text: str) -> int:
+    """Extrai número de sessão de texto como 'session-005'."""
+    m = re.search(r"session-(\d+)", text)
+    return int(m.group(1)) if m else 0
+
+
+def _discover_projects() -> list[ProjectInfo]:
+    """Auto-detecta projetos a partir da estrutura de diretórios."""
+    projects = []
+    for name, display_name in KNOWN_PROJECTS.items():
+        project_path = SKILLS_ROOT / name
+        if project_path.exists() and project_path.is_dir():
+            projects.append(ProjectInfo(
+                name=display_name,
+                path=str(project_path),
+                status="active",
+                last_touched=datetime.now().strftime("%Y-%m-%d"),
+            ))
+    return projects
+
+
+def detect_projects_from_session(files_modified: list[dict], tool_calls: list[dict]) -> list[str]:
+    """Detecta quais projetos foram tocados numa sessão via paths."""
+    touched = set()
+
+    # Verificar arquivos modificados
+    all_paths = [f.get("path", "") for f in files_modified]
+
+    # Verificar tool_calls com file_path
+    for tc in tool_calls:
+        inp = tc.get("input", {})
+        if isinstance(inp, dict):
+            fp = inp.get("file_path", "") or inp.get("path", "")
+            if fp:
+                all_paths.append(fp)
+
+    skills_root_str = str(SKILLS_ROOT).replace("\\", "/").lower()
+    for p in all_paths:
+        p_norm = p.replace("\\", "/").lower()
+        if skills_root_str in p_norm:
+            relative = p_norm.split(skills_root_str)[-1].lstrip("/")
+            top_dir = relative.split("/")[0] if "/" in relative else relative
+            if top_dir in KNOWN_PROJECTS:
+                touched.add(KNOWN_PROJECTS[top_dir])
+
+    return list(touched)
+
+
+def update_project(projects: list[ProjectInfo], name: str, **fields) -> list[ProjectInfo]:
+    """Atualiza campos de um projeto existente ou cria novo."""
+    for p in projects:
+        if p.name == name:
+            for k, v in fields.items():
+                if hasattr(p, k):
+                    setattr(p, k, v)
+            return projects
+
+    # Projeto novo
+    new_project = ProjectInfo(name=name, **fields)
+    projects.append(new_project)
+    return projects
+
+
+def save_registry(projects: list[ProjectInfo]):
+    """Salva PROJECT_REGISTRY.md."""
+    PROJECT_REGISTRY_PATH.parent.mkdir(parents=True, exist_ok=True)
+    now = datetime.now().strftime("%Y-%m-%d %H:%M")
+
+    lines = [
+        f"# Registro de Projetos — Atualizado em {now}",
+        "",
+        "| Projeto | Status | Última Interação | Próximas Ações |",
+        "|---------|--------|------------------|----------------|",
+    ]
+    for p in projects:
+        actions = "; ".join(p.next_actions) if p.next_actions else "—"
+        session_ref = f"session-{p.last_session:03d}" if p.last_session else "—"
+        lines.append(
+            f"| {p.name} | {p.status} | {p.last_touched} ({session_ref}) | {actions} |"
+        )
+
+    lines.append("")
+    PROJECT_REGISTRY_PATH.write_text("\n".join(lines), encoding="utf-8")

package/templates/vault/context-agent/scripts/requirements.txt

@@ -0,0 +1,6 @@
+# Context Agent — Zero dependências externas
+# Usa apenas stdlib Python:
+# - json, sqlite3, pathlib, dataclasses
+# - argparse, datetime, re, shutil, sys
+#
+# Nenhum pip install necessário.

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

@@ -0,0 +1,115 @@
+"""
+Busca full-text via SQLite FTS5 no histórico de sessões.
+"""
+
+import sqlite3
+from pathlib import Path
+
+from config import DB_PATH, MAX_SEARCH_RESULTS
+from models import SearchResult
+
+
+def _get_connection() -> sqlite3.Connection:
+    """Retorna conexão SQLite com FTS5."""
+    DB_PATH.parent.mkdir(parents=True, exist_ok=True)
+    conn = sqlite3.connect(str(DB_PATH))
+    conn.execute("PRAGMA journal_mode=WAL")
+    return conn
+
+
+def init_search_db():
+    """Cria tabela FTS5 se não existir."""
+    conn = _get_connection()
+    conn.execute("""
+        CREATE VIRTUAL TABLE IF NOT EXISTS session_search USING fts5(
+            session_number,
+            date,
+            section,
+            content,
+            tokenize='unicode61'
+        )
+    """)
+    conn.commit()
+    conn.close()
+
+
+def index_session(session_number: int, date: str, sections: dict[str, str]):
+    """
+    Indexa conteúdo de uma sessão.
+    sections: {"topics": "texto", "decisions": "texto", ...}
+    """
+    conn = _get_connection()
+    # Remove entradas antigas da mesma sessão
+    conn.execute(
+        "DELETE FROM session_search WHERE session_number = ?",
+        (str(session_number),),
+    )
+    for section_name, content in sections.items():
+        if content.strip():
+            conn.execute(
+                "INSERT INTO session_search (session_number, date, section, content) VALUES (?, ?, ?, ?)",
+                (str(session_number), date, section_name, content),
+            )
+    conn.commit()
+    conn.close()
+
+
+def search(query: str, limit: int = MAX_SEARCH_RESULTS) -> list[SearchResult]:
+    """Busca full-text no histórico."""
+    conn = _get_connection()
+    try:
+        rows = conn.execute(
+            """
+            SELECT session_number, date, section, snippet(session_search, 3, '>>>', '<<<', '...', 40)
+            FROM session_search
+            WHERE session_search MATCH ?
+            ORDER BY rank
+            LIMIT ?
+            """,
+            (query, limit),
+        ).fetchall()
+    except sqlite3.OperationalError:
+        # Tabela não existe ou query inválida
+        return []
+    finally:
+        conn.close()
+
+    results = []
+    for row in rows:
+        results.append(SearchResult(
+            session_number=int(row[0]),
+            date=row[1],
+            section=row[2],
+            snippet=row[3],
+        ))
+    return results
+
+
+def reindex_all(sessions_dir: Path):
+    """Reconstrói índice a partir dos arquivos de sessão."""
+    conn = _get_connection()
+    conn.execute("DELETE FROM session_search")
+    conn.commit()
+    conn.close()
+
+    for session_file in sorted(sessions_dir.glob("session-*.md")):
+        try:
+            num = int(session_file.stem.split("-")[1])
+        except (IndexError, ValueError):
+            continue
+
+        text = session_file.read_text(encoding="utf-8")
+        date = ""
+        sections = {}
+        current_section = "general"
+
+        for line in text.splitlines():
+            if line.startswith("# Sessão") and "—" in line:
+                date = line.split("—")[-1].strip()
+            elif line.startswith("## "):
+                current_section = line[3:].strip().lower()
+            else:
+                sections.setdefault(current_section, "")
+                sections[current_section] += line + "\n"
+
+        index_session(num, date, sections)

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

@@ -0,0 +1,206 @@
+"""
+Parser dos logs JSONL do Claude Code.
+Lê arquivos de sessão e extrai informações estruturadas.
+"""
+
+import json
+from pathlib import Path
+from datetime import datetime
+from typing import Optional
+
+from config import CLAUDE_SESSION_DIR, FILE_MODIFYING_TOOLS
+from models import SessionEntry
+
+
+def parse_session_file(path: Path) -> list[SessionEntry]:
+    """Lê um arquivo JSONL e retorna lista de SessionEntry."""
+    entries = []
+    with open(path, "r", encoding="utf-8") as f:
+        for line in f:
+            line = line.strip()
+            if not line:
+                continue
+            try:
+                raw = json.loads(line)
+                entry = _parse_raw_entry(raw)
+                if entry:
+                    entries.append(entry)
+            except json.JSONDecodeError:
+                continue
+    return entries
+
+
+def _parse_raw_entry(raw: dict) -> Optional[SessionEntry]:
+    """Converte um dict JSON bruto em SessionEntry."""
+    entry_type = raw.get("type", "")
+
+    if entry_type == "queue-operation":
+        return SessionEntry(
+            type="queue",
+            timestamp=raw.get("timestamp", ""),
+            session_id=raw.get("sessionId", ""),
+            content=raw.get("content", ""),
+        )
+
+    if entry_type not in ("user", "assistant"):
+        return None
+
+    msg = raw.get("message", {})
+    role = msg.get("role", "")
+    slug = raw.get("slug", "")
+    session_id = raw.get("sessionId", "")
+    timestamp = raw.get("timestamp", "")
+
+    # Extrair texto e tool_calls do content
+    text_parts = []
+    tool_calls = []
+    files_modified = []
+    model = msg.get("model", "")
+
+    content = msg.get("content", "")
+    if isinstance(content, str):
+        text_parts.append(content)
+    elif isinstance(content, list):
+        for block in content:
+            if not isinstance(block, dict):
+                continue
+            block_type = block.get("type", "")
+            if block_type == "text":
+                text_parts.append(block.get("text", ""))
+            elif block_type == "tool_use":
+                tool_name = block.get("name", "")
+                tool_input = block.get("input", {})
+                tool_calls.append({"name": tool_name, "input": tool_input})
+                # Detectar arquivos modificados
+                if tool_name in FILE_MODIFYING_TOOLS:
+                    fp = tool_input.get("file_path", "")
+                    if fp:
+                        files_modified.append({"path": fp, "action": tool_name.lower()})
+            elif block_type == "tool_result":
+                # Resultados de ferramentas (em mensagens do user)
+                result_content = block.get("content", "")
+                if isinstance(result_content, list):
+                    for rc in result_content:
+                        if isinstance(rc, dict) and rc.get("type") == "text":
+                            text_parts.append(rc.get("text", ""))
+                elif isinstance(result_content, str):
+                    text_parts.append(result_content)
+
+    # Token usage
+    usage = msg.get("usage", {})
+    token_usage = {}
+    if usage:
+        token_usage = {
+            "input": usage.get("input_tokens", 0),
+            "output": usage.get("output_tokens", 0),
+            "cache_read": usage.get("cache_read_input_tokens", 0),
+            "cache_creation": usage.get("cache_creation_input_tokens", 0),
+        }
+
+    return SessionEntry(
+        type=entry_type,
+        timestamp=timestamp,
+        session_id=session_id,
+        slug=slug,
+        role=role,
+        content="\n".join(text_parts),
+        tool_calls=tool_calls,
+        token_usage=token_usage,
+        model=model,
+        files_modified=files_modified,
+    )
+
+
+def extract_user_messages(entries: list[SessionEntry]) -> list[str]:
+    """Extrai apenas o texto das mensagens do usuário."""
+    return [e.content for e in entries if e.role == "user" and e.content.strip()]
+
+
+def extract_assistant_messages(entries: list[SessionEntry]) -> list[str]:
+    """Extrai apenas o texto das respostas do assistente."""
+    return [e.content for e in entries if e.role == "assistant" and e.content.strip()]
+
+
+def extract_tool_calls(entries: list[SessionEntry]) -> list[dict]:
+    """Extrai todas as chamadas de ferramentas."""
+    calls = []
+    for e in entries:
+        calls.extend(e.tool_calls)
+    return calls
+
+
+def extract_files_modified(entries: list[SessionEntry]) -> list[dict]:
+    """Extrai lista de arquivos modificados (sem duplicatas)."""
+    seen = set()
+    files = []
+    for e in entries:
+        for f in e.files_modified:
+            key = f["path"]
+            if key not in seen:
+                seen.add(key)
+                files.append(f)
+    return files
+
+
+def get_session_metadata(entries: list[SessionEntry]) -> dict:
+    """Extrai metadados da sessão: slug, timestamps, modelo, tokens."""
+    if not entries:
+        return {}
+
+    timestamps = [e.timestamp for e in entries if e.timestamp]
+    slugs = [e.slug for e in entries if e.slug]
+    models = [e.model for e in entries if e.model]
+
+    total_input = sum(e.token_usage.get("input", 0) for e in entries)
+    total_output = sum(e.token_usage.get("output", 0) for e in entries)
+    total_cache = sum(e.token_usage.get("cache_read", 0) for e in entries)
+
+    user_msgs = [e for e in entries if e.role == "user"]
+    assistant_msgs = [e for e in entries if e.role == "assistant"]
+
+    # Calcular duração
+    duration_minutes = 0
+    if len(timestamps) >= 2:
+        try:
+            t_start = datetime.fromisoformat(timestamps[0].replace("Z", "+00:00"))
+            t_end = datetime.fromisoformat(timestamps[-1].replace("Z", "+00:00"))
+            duration_minutes = int((t_end - t_start).total_seconds() / 60)
+        except (ValueError, IndexError):
+            pass
+
+    return {
+        "slug": slugs[0] if slugs else "",
+        "session_id": entries[0].session_id if entries else "",
+        "start_time": timestamps[0] if timestamps else "",
+        "end_time": timestamps[-1] if timestamps else "",
+        "duration_minutes": duration_minutes,
+        "model": models[0] if models else "",
+        "total_input_tokens": total_input,
+        "total_output_tokens": total_output,
+        "total_cache_tokens": total_cache,
+        "message_count": len(user_msgs) + len(assistant_msgs),
+        "tool_call_count": sum(len(e.tool_calls) for e in entries),
+    }
+
+
+def get_latest_session_file() -> Optional[Path]:
+    """Encontra o arquivo JSONL mais recente."""
+    if not CLAUDE_SESSION_DIR.exists():
+        return None
+    jsonl_files = sorted(
+        CLAUDE_SESSION_DIR.glob("*.jsonl"),
+        key=lambda p: p.stat().st_mtime,
+        reverse=True,
+    )
+    return jsonl_files[0] if jsonl_files else None
+
+
+def get_all_session_files() -> list[Path]:
+    """Retorna todos os arquivos JSONL ordenados por data de modificação."""
+    if not CLAUDE_SESSION_DIR.exists():
+        return []
+    return sorted(
+        CLAUDE_SESSION_DIR.glob("*.jsonl"),
+        key=lambda p: p.stat().st_mtime,
+        reverse=True,
+    )