okam 0.2.0__py3-none-any.whl

okam/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.2.0"

okam/cli.py

@@ -0,0 +1,392 @@
+import os
+import sys
+import argparse
+from datetime import datetime
+
+from okam import __version__
+from okam.manager import (
+    get_wiki_files,
+    validate_file,
+    load_markdown_file,
+    save_markdown_file,
+)
+from okam.skill_creator import (
+    create_new_skill,
+    print_colored,
+    ask_question,
+    COLOR_GREEN,
+    COLOR_YELLOW,
+    COLOR_RED,
+    COLOR_BLUE,
+    COLOR_BOLD,
+)
+from okam.hooks import (
+    install_hooks,
+    uninstall_hooks,
+    get_hooks_status,
+    HOOK_NAMES,
+)
+
+
+def get_default_wiki_dir():
+    """Retorna o diretório default do wiki."""
+    # Se ./knowledge/wiki existir no diretório atual, usa ele
+    if os.path.exists(os.path.join("knowledge", "wiki")):
+        return os.path.abspath(os.path.join("knowledge", "wiki"))
+    # Caso contrário, tenta ./wiki
+    if os.path.exists("wiki"):
+        return os.path.abspath("wiki")
+    # Fallback para o valor default
+    return os.path.abspath(os.path.join("knowledge", "wiki"))
+
+
+def cmd_init(wiki_dir):
+    """Gera seed pages com frontmatter OKF válido."""
+    print_colored(f"Inicializando base de conhecimento OKF em: {wiki_dir}...", COLOR_BLUE)
+    os.makedirs(wiki_dir, exist_ok=True)
+    today = datetime.now().strftime("%Y-%m-%d")
+
+    seeds = {
+        "index.md": {
+            "frontmatter": {
+                "title": "Índice do Wiki",
+                "description": "Catálogo central de conhecimento persistente.",
+                "type": "index",
+                "resource": "workspace",
+                "timestamp": today,
+                "tags": ["hub/wiki", "tipo/indice"],
+                "parent": "root"
+            },
+            "body": """
+# Índice do Wiki
+
+Bem-vindo ao catálogo central de conhecimento persistente.
+
+## 00. Visão Geral
+
+- [[getting-started]]: Guia de primeiros passos.
+- [[architecture]]: Visão geral da arquitetura.
+
+## 01. Conceitos
+
+*(Adicione links para páginas de conceitos aqui)*
+
+## 02. Entidades
+
+*(Adicione links para páginas de entidades aqui)*
+"""
+        },
+        "getting-started.md": {
+            "frontmatter": {
+                "title": "Primeiros Passos",
+                "description": "Guia rápido para começar a usar o Wiki de Conhecimento.",
+                "type": "runbook",
+                "resource": "workspace",
+                "timestamp": today,
+                "tags": ["tipo/guia", "onboarding"],
+                "parent": "[[index]]"
+            },
+            "body": """
+# Primeiros Passos
+
+Este guia ajuda você a configurar e começar a usar o Wiki de Conhecimento.
+
+## 1. Estrutura
+
+- `wiki/`: Páginas de síntese (você está aqui).
+- `raw-sources/`: Fontes brutas e imutáveis.
+- `scripts/`: Ferramentas de validação.
+
+## 2. Criar uma Página
+
+Cada página do wiki deve ter frontmatter YAML no formato OKF:
+
+```yaml
+---
+title: "Título da Página"
+description: "Descrição breve do conteúdo."
+type: concept
+resource: workspace
+timestamp: 2026-01-01
+tags:
+  - conceito/exemplo
+parent: "[[index]]"
+---
+```
+
+## 3. Validar
+
+```bash
+okam validate
+```
+"""
+        },
+        "architecture.md": {
+            "frontmatter": {
+                "title": "Arquitetura do Conhecimento",
+                "description": "Visão geral da arquitetura de 3 camadas: Raw Sources, Wiki e Schema.",
+                "type": "architecture",
+                "resource": "workspace",
+                "timestamp": today,
+                "tags": ["conceito/arquitetura", "conceito/okf"],
+                "parent": "[[index]]"
+            },
+            "body": """
+# Arquitetura do Conhecimento
+
+O sistema de conhecimento opera em 3 camadas:
+
+## 1. Raw Sources (Fontes Brutas)
+
+Documentos imutáveis: PDFs, transcrições, logs, clippings.
+Servem como fonte de verdade original.
+
+## 2. Wiki (Síntese)
+
+Páginas de síntese geradas e mantidas por IA.
+Seguem o formato OKF para garantir interoperabilidade.
+
+## 3. Schema (Governança)
+
+Regras definidas em `AGENTS.md` e `.agents/rules/`.
+Controlam como o conhecimento é criado, validado e mantido.
+"""
+        }
+    }
+
+    created = 0
+    for filename, content in seeds.items():
+        filepath = os.path.join(wiki_dir, filename)
+        if os.path.exists(filepath):
+            print_colored(f"  [EXISTE] {filename} — pulando", COLOR_YELLOW)
+            continue
+
+        frontmatter = content["frontmatter"]
+        body = content["body"]
+        save_markdown_file(filepath, frontmatter, body)
+        print_colored(f"  [CRIADO] {filename}", COLOR_GREEN)
+        created += 1
+
+    print_colored(f"\n✅ {created} seed page(s) criada(s) em {wiki_dir}", COLOR_GREEN + COLOR_BOLD)
+
+    # Oferecer instalação de hooks
+    try:
+        resp = ask_question(
+            "Deseja instalar os Git hooks de governança?",
+            default="sim"
+        ).lower()
+        if resp in ['s', 'sim', 'y', 'yes']:
+            print_colored("\nInstalando hooks de governança...", COLOR_BLUE)
+            installed, skipped, errors = install_hooks()
+            if errors == 0:
+                print_colored(
+                    f"✅ {installed} hook(s) instalado(s).",
+                    COLOR_GREEN + COLOR_BOLD
+                )
+            else:
+                print_colored(
+                    f"⚠ {installed} instalado(s), {errors} erro(s).",
+                    COLOR_YELLOW
+                )
+    except (KeyboardInterrupt, EOFError):
+        pass  # Non-interactive ou cancelado — pular silenciosamente
+
+
+def cmd_validate(wiki_dir):
+    """Valida todos os arquivos .md no wiki_dir contra o padrão OKF."""
+    files = get_wiki_files(wiki_dir)
+
+    if not files:
+        print_colored(f"Nenhum arquivo .md encontrado em: {wiki_dir}", COLOR_YELLOW)
+        return True
+
+    all_ok = True
+    print_colored(f"Validando conformidade OKF em: {wiki_dir}...\n", COLOR_BLUE)
+
+    for filepath in files:
+        filename = os.path.basename(filepath)
+        is_ok, errors = validate_file(filepath)
+        if is_ok:
+            print_colored(f"  [OK] {filename}", COLOR_GREEN)
+        else:
+            all_ok = False
+            print_colored(f"  [FALHA] {filename}", COLOR_RED)
+            for err in errors:
+                print(f"    - {err}")
+
+    if all_ok:
+        print_colored("\n✅ Todos os arquivos estão em conformidade com o OKF!", COLOR_GREEN + COLOR_BOLD)
+        return True
+    else:
+        print_colored("\n❌ Validação falhou com erros.", COLOR_RED + COLOR_BOLD)
+        return False
+
+
+def cmd_index(wiki_dir):
+    """Gera índice markdown da base OKF e exibe no stdout."""
+    files = get_wiki_files(wiki_dir)
+
+    print("# Índice de Conhecimento OKF\n")
+    print("| Arquivo | Título | Tipo | Recurso | Data | Descrição |")
+    print("| --- | --- | --- | --- | --- | --- |")
+
+    for filepath in files:
+        filename = os.path.basename(filepath)
+        try:
+            frontmatter, _ = load_markdown_file(filepath)
+            if not frontmatter:
+                continue
+        except Exception:
+            continue
+
+        title = frontmatter.get('title', filename)
+        ftype = frontmatter.get('type', '-')
+        resource = frontmatter.get('resource', '-')
+        timestamp = frontmatter.get('timestamp', '-')
+        description = frontmatter.get('description', '-')
+
+        print(f"| {filename} | {title} | {ftype} | {resource} | {timestamp} | {description} |")
+
+def cmd_hooks(args):
+    """Gerencia Git hooks de governança do Okam."""
+    action = getattr(args, "hooks_action", None)
+
+    if action is None:
+        print_colored("Uso: okam hooks {install|uninstall|status}", COLOR_YELLOW)
+        print_colored("  install    — Instala hooks de governança no repositório", COLOR_BLUE)
+        print_colored("  uninstall  — Remove hooks do Okam e restaura backups", COLOR_BLUE)
+        print_colored("  status     — Mostra o status de cada hook", COLOR_BLUE)
+        sys.exit(0)
+
+    if action == "install":
+        print_colored("⬡ Instalando hooks de governança...\n", COLOR_BLUE + COLOR_BOLD)
+        skip = []
+        if getattr(args, "skip_commit_msg", False):
+            skip.append("commit-msg")
+        installed, skipped, errors = install_hooks(skip_hooks=skip)
+        print()
+        if errors == 0:
+            print_colored(
+                f"✅ {installed} hook(s) instalado(s), {skipped} pulado(s).",
+                COLOR_GREEN + COLOR_BOLD,
+            )
+        else:
+            print_colored(
+                f"⚠ {installed} instalado(s), {errors} erro(s).",
+                COLOR_RED + COLOR_BOLD,
+            )
+            sys.exit(1)
+
+    elif action == "uninstall":
+        print_colored("⬡ Removendo hooks de governança...\n", COLOR_BLUE + COLOR_BOLD)
+        removed, restored, not_found = uninstall_hooks()
+        print()
+        total = removed + restored
+        if total > 0:
+            print_colored(
+                f"✅ {total} hook(s) removido(s) ({restored} backup(s) restaurado(s)).",
+                COLOR_GREEN + COLOR_BOLD,
+            )
+        else:
+            print_colored("Nenhum hook do Okam encontrado para remover.", COLOR_YELLOW)
+
+    elif action == "status":
+        print_colored("⬡ Status dos hooks de governança:\n", COLOR_BLUE + COLOR_BOLD)
+        status = get_hooks_status()
+        for hook_name, state in status.items():
+            if "Okam" in state:
+                color = COLOR_GREEN
+                icon = "✓"
+            elif "externo" in state:
+                color = COLOR_YELLOW
+                icon = "~"
+            else:
+                color = COLOR_RED
+                icon = "✗"
+            print_colored(f"  {icon} {hook_name}: {state}", color)
+        print()
+
+
+def main():
+    # Configura encoding UTF-8 para Windows se executado diretamente
+    if sys.platform.startswith('win'):
+        import io
+        sys.stdout = io.TextIOWrapper(sys.stdout.buffer, encoding='utf-8')
+        sys.stderr = io.TextIOWrapper(sys.stderr.buffer, encoding='utf-8')
+
+    parser = argparse.ArgumentParser(
+        description="⬡ Okam CLI — Framework de governança de IA e memória persistente",
+        formatter_class=argparse.RawDescriptionHelpFormatter
+    )
+    parser.add_argument(
+        '--version', '-v',
+        action='version',
+        version=f"okam version {__version__}"
+    )
+
+    subparsers = parser.add_subparsers(dest="command", help="Comando a ser executado")
+
+    # Comando init
+    p_init = subparsers.add_parser("init", help="Inicializa wiki com seed pages OKF")
+    p_init.add_argument("--wiki-dir", help="Diretório destino do wiki (default: autodetect ./knowledge/wiki)")
+
+    # Comando validate
+    p_val = subparsers.add_parser("validate", help="Valida conformidade OKF de arquivos Markdown")
+    p_val.add_argument("--wiki-dir", help="Diretório do wiki a validar (default: autodetect ./knowledge/wiki)")
+
+    # Comando index
+    p_idx = subparsers.add_parser("index", help="Gera tabela Markdown do índice de conhecimento")
+    p_idx.add_argument("--wiki-dir", help="Diretório do wiki (default: autodetect ./knowledge/wiki)")
+
+    # Adiciona compatibilidade para dump-index diretamente
+    p_dump = subparsers.add_parser("dump-index", help="Alias para o comando 'index'")
+    p_dump.add_argument("--wiki-dir", help="Diretório do wiki (default: autodetect ./knowledge/wiki)")
+
+    # Comando new-skill
+    subparsers.add_parser("new-skill", help="Cria interativamente uma nova skill na pasta .agents/skills")
+
+    # Comando hooks
+    p_hooks = subparsers.add_parser("hooks", help="Gerencia Git hooks de governança")
+    p_hooks_sub = p_hooks.add_subparsers(dest="hooks_action", help="Ação dos hooks")
+
+    p_hooks_install = p_hooks_sub.add_parser("install", help="Instala hooks de governança no repositório")
+    p_hooks_install.add_argument(
+        "--skip-commit-msg",
+        action="store_true",
+        help="Não instalar o hook de Conventional Commits"
+    )
+
+    p_hooks_sub.add_parser("uninstall", help="Remove hooks do Okam e restaura backups")
+    p_hooks_sub.add_parser("status", help="Mostra o status de cada hook de governança")
+
+    args = parser.parse_args()
+
+    if not args.command:
+        parser.print_help()
+        sys.exit(0)
+
+    # Roteamento dos comandos
+    wiki_dir = None
+    if hasattr(args, "wiki_dir") and args.wiki_dir:
+        wiki_dir = os.path.abspath(args.wiki_dir)
+    else:
+        wiki_dir = get_default_wiki_dir()
+
+    if args.command == "init":
+        cmd_init(wiki_dir)
+    elif args.command == "validate":
+        success = cmd_validate(wiki_dir)
+        sys.exit(0 if success else 1)
+    elif args.command in ["index", "dump-index"]:
+        if not os.path.exists(wiki_dir):
+            print_colored(f"Erro: Diretório do wiki não encontrado em {wiki_dir}", COLOR_RED)
+            sys.exit(1)
+        cmd_index(wiki_dir)
+    elif args.command == "new-skill":
+        create_new_skill()
+    elif args.command == "hooks":
+        cmd_hooks(args)
+
+
+if __name__ == "__main__":
+    main()

okam/hooks/commit-msg

@@ -0,0 +1,58 @@
+#!/bin/sh
+# ⬡ Okam — Commit-msg Hook
+# Enforces Conventional Commits format on commit messages.
+# Part of the Okam governance framework. Install via: okam hooks install
+
+# ── Colors ──────────────────────────────────────────────────────────────────
+RED='\033[0;31m'
+GREEN='\033[0;32m'
+YELLOW='\033[0;33m'
+BOLD='\033[1m'
+RESET='\033[0m'
+
+COMMIT_MSG_FILE="$1"
+
+if [ ! -f "$COMMIT_MSG_FILE" ]; then
+    printf "${RED}⬡ Okam commit-msg: Arquivo de mensagem não encontrado.${RESET}\n"
+    exit 1
+fi
+
+# Read the first line (subject) of the commit message
+FIRST_LINE=$(head -n1 "$COMMIT_MSG_FILE")
+
+# Skip merge commits and fixup/squash commits
+case "$FIRST_LINE" in
+    Merge*|Revert*|fixup!*|squash!*|amend!*)
+        exit 0
+        ;;
+esac
+
+# Conventional Commits regex:
+# <type>[optional scope][optional !]: <description>
+# Types: feat, fix, docs, style, refactor, perf, test, build, ci, chore, revert
+PATTERN='^(feat|fix|docs|style|refactor|perf|test|build|ci|chore|revert)(\([a-zA-Z0-9._-]+\))?(!)?: .{1,}'
+
+if ! echo "$FIRST_LINE" | grep -qE "$PATTERN"; then
+    printf "\n${RED}${BOLD}⬡ Okam commit-msg: Mensagem fora do padrão Conventional Commits.${RESET}\n"
+    printf "${RED}  Recebido: ${FIRST_LINE}${RESET}\n"
+    printf "\n${YELLOW}  Formato esperado: <tipo>[escopo opcional]: <descrição>${RESET}\n"
+    printf "${YELLOW}  Tipos válidos: feat, fix, docs, style, refactor, perf, test, build, ci, chore, revert${RESET}\n"
+    printf "\n${YELLOW}  Exemplos:${RESET}\n"
+    printf "${GREEN}    feat: adiciona autenticação OAuth${RESET}\n"
+    printf "${GREEN}    fix(api): corrige timeout no endpoint de login${RESET}\n"
+    printf "${GREEN}    docs: atualiza README com instruções de deploy${RESET}\n"
+    printf "${GREEN}    feat!: breaking change na API de pagamentos${RESET}\n"
+    printf "\n${YELLOW}  Para bypass emergencial: git commit --no-verify${RESET}\n"
+    exit 1
+fi
+
+# Validate subject line length (soft warning at 72, hard fail at 100)
+SUBJECT_LEN=$(printf '%s' "$FIRST_LINE" | wc -c)
+if [ "$SUBJECT_LEN" -gt 100 ]; then
+    printf "${RED}${BOLD}⬡ Okam commit-msg: Linha de assunto muito longa (${SUBJECT_LEN} chars, max 100).${RESET}\n"
+    exit 1
+elif [ "$SUBJECT_LEN" -gt 72 ]; then
+    printf "${YELLOW}⬡ Okam commit-msg: Linha de assunto longa (${SUBJECT_LEN} chars, recomendado ≤72).${RESET}\n"
+fi
+
+exit 0

okam/hooks/pre-commit

@@ -0,0 +1,114 @@
+#!/bin/sh
+# ⬡ Okam — Pre-commit Hook
+# Validates OKF compliance for staged wiki files and detects leaked secrets.
+# Part of the Okam governance framework. Install via: okam hooks install
+
+set -e
+
+# ── Colors ──────────────────────────────────────────────────────────────────
+RED='\033[0;31m'
+GREEN='\033[0;32m'
+YELLOW='\033[0;33m'
+BLUE='\033[0;34m'
+BOLD='\033[1m'
+RESET='\033[0m'
+
+ERRORS=0
+
+# ── 1. OKF Validation ──────────────────────────────────────────────────────
+# Find staged .md files in wiki directories
+WIKI_FILES=$(git diff --cached --name-only --diff-filter=ACM | grep -E '(knowledge/wiki|wiki)/.*\.md$' || true)
+
+if [ -n "$WIKI_FILES" ]; then
+    printf "${BLUE}${BOLD}⬡ Okam pre-commit: Validando conformidade OKF...${RESET}\n"
+
+    # Check if okam CLI is available
+    if command -v okam >/dev/null 2>&1; then
+        for file in $WIKI_FILES; do
+            # Validate the staged version by using the working copy
+            # (okam validate works on files in the filesystem)
+            WIKI_DIR=$(dirname "$file")
+            RESULT=$(okam validate --wiki-dir "$WIKI_DIR" 2>&1) || true
+
+            BASENAME=$(basename "$file")
+            if echo "$RESULT" | grep -q "\[FALHA\] $BASENAME"; then
+                printf "${RED}  ✗ ${BASENAME}${RESET}\n"
+                echo "$RESULT" | grep -A5 "\[FALHA\] $BASENAME" | grep "^    -" || true
+                ERRORS=$((ERRORS + 1))
+            else
+                printf "${GREEN}  ✓ ${BASENAME}${RESET}\n"
+            fi
+        done
+    else
+        printf "${YELLOW}  ⚠ okam CLI não encontrado. Pulando validação OKF.${RESET}\n"
+        printf "${YELLOW}    Instale com: pip install -e . (na raiz do projeto Okam)${RESET}\n"
+    fi
+fi
+
+# ── 2. Secret Detection ────────────────────────────────────────────────────
+STAGED_FILES=$(git diff --cached --name-only --diff-filter=ACM || true)
+
+if [ -n "$STAGED_FILES" ]; then
+    # Check for .env files being committed
+    ENV_FILES=$(echo "$STAGED_FILES" | grep -E '\.env($|\.)' | grep -v '\.env\.example$' || true)
+    if [ -n "$ENV_FILES" ]; then
+        printf "\n${RED}${BOLD}⬡ Okam pre-commit: Arquivos .env detectados!${RESET}\n"
+        for f in $ENV_FILES; do
+            printf "${RED}  ✗ ${f}${RESET}\n"
+        done
+        printf "${YELLOW}  → Adicione ao .gitignore ou use .env.example como template.${RESET}\n"
+        ERRORS=$((ERRORS + 1))
+    fi
+
+    # Scan staged content for secret patterns
+    SECRET_FOUND=0
+    for file in $STAGED_FILES; do
+        # Skip binary files and known safe extensions
+        case "$file" in
+            *.png|*.jpg|*.jpeg|*.gif|*.ico|*.woff|*.woff2|*.ttf|*.eot|*.svg|*.mp4|*.zip|*.tar|*.gz)
+                continue
+                ;;
+        esac
+
+        # Get staged content (not working copy)
+        CONTENT=$(git show ":$file" 2>/dev/null) || continue
+
+        # AWS Access Key IDs
+        if echo "$CONTENT" | grep -qE 'AKIA[0-9A-Z]{16}'; then
+            printf "${RED}  ✗ Possível AWS Key em: ${file}${RESET}\n"
+            SECRET_FOUND=1
+        fi
+
+        # OpenAI / Anthropic / Generic API keys
+        if echo "$CONTENT" | grep -qE '(sk-[a-zA-Z0-9]{20,}|ghp_[a-zA-Z0-9]{36}|glpat-[a-zA-Z0-9\-]{20,}|xoxb-[0-9]{10,})'; then
+            printf "${RED}  ✗ Possível API key/token em: ${file}${RESET}\n"
+            SECRET_FOUND=1
+        fi
+
+        # Generic secret assignments (password, secret, token with long values)
+        if echo "$CONTENT" | grep -qiE '(password|secret|token|api_key|apikey|private_key)\s*[=:]\s*["\x27][^\s"'\'']{12,}'; then
+            printf "${RED}  ✗ Possível segredo hardcoded em: ${file}${RESET}\n"
+            SECRET_FOUND=1
+        fi
+    done
+
+    if [ "$SECRET_FOUND" -eq 1 ]; then
+        printf "\n${RED}${BOLD}⬡ Okam pre-commit: Segredos detectados!${RESET}\n"
+        printf "${YELLOW}  → Remova os segredos e use variáveis de ambiente.${RESET}\n"
+        printf "${YELLOW}  → Para scan mais robusto, considere: https://github.com/gitleaks/gitleaks${RESET}\n"
+        ERRORS=$((ERRORS + 1))
+    fi
+fi
+
+# ── Result ──────────────────────────────────────────────────────────────────
+if [ "$ERRORS" -gt 0 ]; then
+    printf "\n${RED}${BOLD}⬡ Okam: Commit bloqueado — corrija os erros acima.${RESET}\n"
+    printf "${YELLOW}  Para bypass emergencial: git commit --no-verify${RESET}\n"
+    exit 1
+fi
+
+if [ -n "$WIKI_FILES" ]; then
+    printf "${GREEN}${BOLD}⬡ Okam: Todas as verificações passaram.${RESET}\n"
+fi
+
+exit 0

okam/hooks/pre-push

@@ -0,0 +1,36 @@
+#!/bin/sh
+# ⬡ Okam — Pre-push Hook
+# Runs full OKF validation before pushing to remote.
+# Part of the Okam governance framework. Install via: okam hooks install
+
+set -e
+
+# ── Colors ──────────────────────────────────────────────────────────────────
+RED='\033[0;31m'
+GREEN='\033[0;32m'
+YELLOW='\033[0;33m'
+BLUE='\033[0;34m'
+BOLD='\033[1m'
+RESET='\033[0m'
+
+printf "${BLUE}${BOLD}⬡ Okam pre-push: Executando validação OKF completa...${RESET}\n"
+
+# Check if okam CLI is available
+if ! command -v okam >/dev/null 2>&1; then
+    printf "${YELLOW}  ⚠ okam CLI não encontrado. Pulando validação OKF.${RESET}\n"
+    printf "${YELLOW}    Instale com: pip install -e . (na raiz do projeto Okam)${RESET}\n"
+    exit 0
+fi
+
+# Run full validation
+if okam validate >/dev/null 2>&1; then
+    printf "${GREEN}${BOLD}⬡ Okam pre-push: Validação OKF completa — tudo OK.${RESET}\n"
+    exit 0
+else
+    printf "\n${RED}${BOLD}⬡ Okam pre-push: Validação OKF falhou!${RESET}\n"
+    printf "${YELLOW}  Detalhes:${RESET}\n"
+    okam validate 2>&1 | grep -E '\[(FALHA|OK)\]' || okam validate 2>&1
+    printf "\n${YELLOW}  Corrija os erros antes de enviar ao remote.${RESET}\n"
+    printf "${YELLOW}  Para bypass emergencial: git push --no-verify${RESET}\n"
+    exit 1
+fi

okam/hooks.py

@@ -0,0 +1,213 @@
+"""
+Okam Git Hooks Manager — Instala, desinstala e verifica hooks de governança.
+
+Hooks portáveis (POSIX shell) que rodam validação OKF, detecção de segredos
+e Conventional Commits antes de commits e pushes.
+"""
+
+import os
+import shutil
+import stat
+import sys
+
+from okam.skill_creator import (
+    print_colored,
+    find_workspace_root,
+    COLOR_GREEN,
+    COLOR_YELLOW,
+    COLOR_RED,
+    COLOR_BLUE,
+    COLOR_BOLD,
+)
+
+# Hooks que o Okam gerencia
+HOOK_NAMES = ["pre-commit", "commit-msg", "pre-push"]
+
+# Marcador para identificar hooks instalados pelo Okam
+OKAM_MARKER = "# ⬡ Okam"
+
+
+def _get_hooks_source_dir():
+    """Retorna o diretório onde os hook scripts do Okam estão armazenados."""
+    # Tenta encontrar a pasta hooks/ relativa ao pacote instalado
+    # Primeiro: relativo ao workspace root (dev mode / pip install -e .)
+    workspace = find_workspace_root()
+    hooks_dir = os.path.join(workspace, "hooks")
+    if os.path.isdir(hooks_dir):
+        return hooks_dir
+
+    # Fallback: relativo ao pacote Python instalado
+    package_dir = os.path.dirname(os.path.abspath(__file__))
+    hooks_dir = os.path.join(package_dir, "hooks")
+    if os.path.isdir(hooks_dir):
+        return hooks_dir
+
+    return None
+
+
+def _get_git_hooks_dir(repo_root=None):
+    """Retorna o caminho para .git/hooks/ do repositório."""
+    if repo_root is None:
+        repo_root = find_workspace_root()
+
+    git_dir = os.path.join(repo_root, ".git")
+
+    # Suporta git worktrees onde .git é um arquivo apontando para o gitdir
+    if os.path.isfile(git_dir):
+        with open(git_dir, "r", encoding="utf-8") as f:
+            content = f.read().strip()
+        if content.startswith("gitdir:"):
+            git_dir = content[7:].strip()
+            if not os.path.isabs(git_dir):
+                git_dir = os.path.normpath(os.path.join(repo_root, git_dir))
+
+    hooks_dir = os.path.join(git_dir, "hooks")
+    return hooks_dir
+
+
+def _is_okam_hook(filepath):
+    """Verifica se um hook foi instalado pelo Okam (contém o marcador)."""
+    if not os.path.exists(filepath):
+        return False
+    try:
+        with open(filepath, "r", encoding="utf-8") as f:
+            content = f.read(512)  # Ler só o início
+        return OKAM_MARKER in content
+    except (OSError, UnicodeDecodeError):
+        return False
+
+
+def install_hooks(repo_root=None, skip_hooks=None):
+    """
+    Instala hooks de governança do Okam no repositório.
+
+    Args:
+        repo_root: Raiz do repositório Git. Se None, autodetecta.
+        skip_hooks: Lista de nomes de hooks para pular (ex: ['commit-msg']).
+
+    Returns:
+        Tuple (installed, skipped, errors) com contagens.
+    """
+    if skip_hooks is None:
+        skip_hooks = []
+
+    source_dir = _get_hooks_source_dir()
+    if source_dir is None:
+        print_colored(
+            "Erro: Pasta 'hooks/' não encontrada. Verifique a instalação do Okam.",
+            COLOR_RED,
+        )
+        return 0, 0, 1
+
+    git_hooks_dir = _get_git_hooks_dir(repo_root)
+    os.makedirs(git_hooks_dir, exist_ok=True)
+
+    installed = 0
+    skipped = 0
+    errors = 0
+
+    for hook_name in HOOK_NAMES:
+        if hook_name in skip_hooks:
+            print_colored(f"  [PULADO] {hook_name} (--skip-{hook_name})", COLOR_YELLOW)
+            skipped += 1
+            continue
+
+        source_path = os.path.join(source_dir, hook_name)
+        target_path = os.path.join(git_hooks_dir, hook_name)
+
+        if not os.path.exists(source_path):
+            print_colored(
+                f"  [ERRO] Script fonte não encontrado: {source_path}", COLOR_RED
+            )
+            errors += 1
+            continue
+
+        # Se já existe um hook que NÃO é do Okam, fazer backup
+        if os.path.exists(target_path) and not _is_okam_hook(target_path):
+            backup_path = target_path + ".bak"
+            shutil.copy2(target_path, backup_path)
+            print_colored(
+                f"  [BACKUP] {hook_name} existente salvo em {hook_name}.bak",
+                COLOR_YELLOW,
+            )
+
+        # Copiar o hook
+        shutil.copy2(source_path, target_path)
+
+        # Setar permissão de execução (no-op funcional no Windows)
+        try:
+            current = os.stat(target_path).st_mode
+            os.chmod(target_path, current | stat.S_IEXEC | stat.S_IXGRP | stat.S_IXOTH)
+        except OSError:
+            pass  # Windows pode não suportar chmod, mas Git for Windows não precisa
+
+        print_colored(f"  [INSTALADO] {hook_name}", COLOR_GREEN)
+        installed += 1
+
+    return installed, skipped, errors
+
+
+def uninstall_hooks(repo_root=None):
+    """
+    Remove hooks do Okam e restaura backups se existirem.
+
+    Returns:
+        Tuple (removed, restored, not_found) com contagens.
+    """
+    git_hooks_dir = _get_git_hooks_dir(repo_root)
+
+    removed = 0
+    restored = 0
+    not_found = 0
+
+    for hook_name in HOOK_NAMES:
+        target_path = os.path.join(git_hooks_dir, hook_name)
+        backup_path = target_path + ".bak"
+
+        if not os.path.exists(target_path):
+            print_colored(f"  [NÃO ENCONTRADO] {hook_name}", COLOR_YELLOW)
+            not_found += 1
+            continue
+
+        if not _is_okam_hook(target_path):
+            print_colored(
+                f"  [PULADO] {hook_name} — não foi instalado pelo Okam", COLOR_YELLOW
+            )
+            continue
+
+        os.remove(target_path)
+
+        if os.path.exists(backup_path):
+            shutil.move(backup_path, target_path)
+            print_colored(
+                f"  [RESTAURADO] {hook_name} (backup restaurado)", COLOR_GREEN
+            )
+            restored += 1
+        else:
+            print_colored(f"  [REMOVIDO] {hook_name}", COLOR_GREEN)
+            removed += 1
+
+    return removed, restored, not_found
+
+
+def get_hooks_status(repo_root=None):
+    """
+    Verifica o status de cada hook de governança.
+
+    Returns:
+        Dict {hook_name: status_string}
+    """
+    git_hooks_dir = _get_git_hooks_dir(repo_root)
+    status = {}
+
+    for hook_name in HOOK_NAMES:
+        target_path = os.path.join(git_hooks_dir, hook_name)
+
+        if not os.path.exists(target_path):
+            status[hook_name] = "não instalado"
+        elif _is_okam_hook(target_path):
+            status[hook_name] = "instalado (Okam)"
+        else:
+            status[hook_name] = "instalado (externo)"
+
+    return status

okam/manager.py

@@ -0,0 +1,155 @@
+import os
+import re
+import sys
+from datetime import datetime
+
+VALID_TYPES = {"index", "concept", "architecture", "runbook", "entity", "benchmark"}
+
+
+def parse_simple_yaml(yaml_str):
+    """Parser minimalista de YAML para frontmatter. Sem dependências externas."""
+    lines = yaml_str.splitlines()
+    data = {}
+    current_key = None
+    for line in lines:
+        stripped = line.strip()
+        if not stripped or stripped.startswith('#'):
+            continue
+
+        match = re.match(r'^([a-zA-Z0-9_\-]+)\s*:\s*(.*)$', line)
+        if match:
+            current_key = match.group(1)
+            val = match.group(2).strip()
+            if val.startswith('[') and val.endswith(']'):
+                items = [x.strip() for x in val[1:-1].split(',')]
+                cleaned_items = []
+                for x in items:
+                    if (x.startswith('"') and x.endswith('"')) or (x.startswith("'") and x.endswith("'")):
+                        x = x[1:-1]
+                    cleaned_items.append(x)
+                data[current_key] = cleaned_items
+            elif val == "":
+                data[current_key] = None
+            else:
+                if (val.startswith('"') and val.endswith('"')) or (val.startswith("'") and val.endswith("'")):
+                    val = val[1:-1]
+                data[current_key] = val
+        elif line.startswith('  - ') and current_key:
+            val = line[4:].strip()
+            if (val.startswith('"') and val.endswith('"')) or (val.startswith("'") and val.endswith("'")):
+                val = val[1:-1]
+            if not isinstance(data.get(current_key), list):
+                data[current_key] = []
+            data[current_key].append(val)
+    return data
+
+
+def serialize_simple_yaml(data):
+    """Serializa dicionário para YAML simples."""
+    lines = []
+    for key, val in data.items():
+        if val is None:
+            lines.append(f"{key}:")
+        elif isinstance(val, list):
+            if len(val) == 0:
+                lines.append(f"{key}: []")
+            else:
+                lines.append(f"{key}:")
+                for item in val:
+                    lines.append(f"  - {item}")
+        elif isinstance(val, str):
+            if any(c in val for c in [':', '#', '[', ']', '{', '}', ',', '"', "'"]) or val.strip() != val:
+                escaped = val.replace('"', '\\"')
+                lines.append(f'{key}: "{escaped}"')
+            else:
+                lines.append(f"{key}: {val}")
+        else:
+            lines.append(f"{key}: {val}")
+    return "\n".join(lines)
+
+
+def load_markdown_file(filepath):
+    """Carrega um arquivo Markdown e separa frontmatter do corpo."""
+    with open(filepath, 'r', encoding='utf-8') as f:
+        content = f.read()
+
+    frontmatter = {}
+    body = content
+    match = re.match(r'^---\s*\n(.*?)\n---\s*\n', content, re.DOTALL)
+    if match:
+        yaml_content = match.group(1)
+        try:
+            frontmatter = parse_simple_yaml(yaml_content)
+            body = content[match.end():]
+        except Exception as e:
+            raise ValueError(f"Erro ao parsear YAML em {os.path.basename(filepath)}: {e}")
+
+    return frontmatter, body
+
+
+def save_markdown_file(filepath, frontmatter, body):
+    """Salva arquivo Markdown com frontmatter YAML ordenado."""
+    ordered_keys = ['title', 'description', 'type', 'resource', 'timestamp', 'tags', 'parent']
+    ordered_fm = {}
+
+    for key in ordered_keys:
+        if key in frontmatter:
+            ordered_fm[key] = frontmatter[key]
+
+    for key, val in frontmatter.items():
+        if key not in ordered_keys:
+            ordered_fm[key] = val
+
+    yaml_str = serialize_simple_yaml(ordered_fm).strip()
+
+    with open(filepath, 'w', encoding='utf-8') as f:
+        f.write(f"---\n{yaml_str}\n---\n{body}")
+
+
+def extract_h1(body):
+    """Extrai o primeiro heading H1 do corpo do documento."""
+    match = re.search(r'^#\s+(.+)$', body, re.MULTILINE)
+    return match.group(1).strip() if match else ""
+
+
+def validate_file(filepath):
+    """Valida um arquivo contra o padrão OKF. Retorna (is_valid, errors)."""
+    try:
+        frontmatter, body = load_markdown_file(filepath)
+    except Exception as e:
+        return False, [str(e)]
+
+    if frontmatter is None:
+        return False, ["Erro de parse no YAML"]
+
+    errors = []
+
+    required_keys = ['title', 'description', 'type', 'resource', 'timestamp', 'tags', 'parent']
+    for key in required_keys:
+        if key not in frontmatter or frontmatter[key] is None:
+            errors.append(f"Chave obrigatória ausente: '{key}'")
+
+    if 'type' in frontmatter and frontmatter['type'] not in VALID_TYPES:
+        errors.append(f"Tipo inválido '{frontmatter['type']}'. Deve ser: {', '.join(VALID_TYPES)}")
+
+    if 'timestamp' in frontmatter:
+        ts = str(frontmatter['timestamp'])
+        if not re.match(r'^\d{4}-\d{2}-\d{2}$', ts):
+            errors.append(f"Formato de timestamp inválido '{ts}'. Deve ser YYYY-MM-DD")
+
+    if 'title' in frontmatter and body:
+        expected_title = extract_h1(body)
+        if expected_title and frontmatter['title'] != expected_title:
+            errors.append(f"Título no frontmatter ('{frontmatter['title']}') difere do H1 ('{expected_title}')")
+
+    return len(errors) == 0, errors
+
+
+def get_wiki_files(wiki_dir):
+    """Retorna todos os arquivos .md de um wiki_dir."""
+    files = []
+    for root, _, filenames in os.walk(wiki_dir):
+        for f in filenames:
+            if f.endswith('.md'):
+                files.append(os.path.join(root, f))
+    return sorted(files)

okam/skill_creator.py

@@ -0,0 +1,166 @@
+import os
+import re
+import sys
+
+# Cores ANSI
+COLOR_GREEN = "\033[92m"
+COLOR_BLUE = "\033[94m"
+COLOR_YELLOW = "\033[93m"
+COLOR_RED = "\033[91m"
+COLOR_BOLD = "\033[1m"
+COLOR_RESET = "\033[0m"
+
+
+def print_colored(text, color):
+    """Imprime texto colorido se o terminal suportar."""
+    # Ativa suporte a ANSI no Windows 10+
+    if sys.platform.startswith('win'):
+        os.system('')
+    sys.stdout.write(f"{color}{text}{COLOR_RESET}\n")
+    sys.stdout.flush()
+
+
+def find_workspace_root():
+    """Sobe a árvore de diretórios a partir do atual para achar a raiz do workspace."""
+    current = os.path.abspath(os.getcwd())
+    while True:
+        # Indicadores de raiz do workspace okam/Juliano
+        indicators = ['.git', '.agents', 'AGENTS.md', 'Dashboard_Central.md']
+        for ind in indicators:
+            if os.path.exists(os.path.join(current, ind)):
+                return current
+        
+        parent = os.path.dirname(current)
+        if parent == current:
+            # Chegou na raiz do sistema de arquivos
+            break
+        current = parent
+    
+    return os.path.abspath(os.getcwd())
+
+
+def ask_question(prompt_text, default=None, validator=None):
+    """Faz uma pergunta ao usuário no terminal e retorna a resposta validada."""
+    while True:
+        display = f"{COLOR_BOLD}{prompt_text}{COLOR_RESET}"
+        if default is not None:
+            display += f" [{COLOR_BLUE}{default}{COLOR_RESET}]"
+        display += ": "
+        
+        try:
+            resp = input(display).strip()
+        except (KeyboardInterrupt, EOFError):
+            print_colored("\nOperação cancelada pelo usuário.", COLOR_RED)
+            sys.exit(1)
+            
+        if not resp and default is not None:
+            resp = default
+            
+        if not resp:
+            print_colored("A resposta não pode ser vazia.", COLOR_YELLOW)
+            continue
+            
+        if validator:
+            is_valid, err_msg = validator(resp)
+            if not is_valid:
+                print_colored(err_msg, COLOR_RED)
+                continue
+                
+        return resp
+
+
+def validate_skill_name(name):
+    """Valida se o nome da skill é seguro e segue o padrão kebab-case."""
+    if not re.match(r'^[a-z0-9\-]+$', name):
+        return False, "O nome da skill deve conter apenas letras minúsculas, números e hifens (ex: minha-nova-skill)."
+    return True, ""
+
+
+def create_new_skill():
+    """Fluxo interativo de criação de uma nova skill."""
+    print_colored("\n⬡ Criando Nova Skill para o Agente ⬡\n", COLOR_BLUE + COLOR_BOLD)
+    
+    workspace_root = find_workspace_root()
+    agents_dir = os.path.join(workspace_root, ".agents")
+    skills_dir = os.path.join(agents_dir, "skills")
+    
+    if not os.path.exists(agents_dir):
+        print_colored(f"Aviso: Diretório de governança '.agents' não encontrado na raiz: {workspace_root}", COLOR_YELLOW)
+        # Pergunta se quer criar a pasta .agents
+        confirm = ask_question("Deseja criar a pasta '.agents' na raiz deste diretório?", "sim").lower()
+        if confirm in ['s', 'sim', 'y', 'yes']:
+            os.makedirs(skills_dir, exist_ok=True)
+        else:
+            print_colored("Cancelado. Não é possível prosseguir sem a pasta de destino.", COLOR_RED)
+            sys.exit(1)
+    else:
+        os.makedirs(skills_dir, exist_ok=True)
+
+    skill_name = ask_question("Nome da Skill (kebab-case)", validator=validate_skill_name)
+    
+    target_skill_dir = os.path.join(skills_dir, skill_name)
+    if os.path.exists(target_skill_dir):
+        print_colored(f"Erro: A skill '{skill_name}' já existe em: {target_skill_dir}", COLOR_RED)
+        sys.exit(1)
+        
+    description = ask_question("Descrição da Skill (uma frase clara do que ela faz)")
+    version = ask_question("Versão inicial", default="1.0")
+    
+    priority = ask_question(
+        "Prioridade (CRITICAL, HIGH, NORMAL, LOW)", 
+        default="NORMAL", 
+        validator=lambda x: (x.upper() in ["CRITICAL", "HIGH", "NORMAL", "LOW"], "Prioridade inválida. Escolha entre: CRITICAL, HIGH, NORMAL, LOW.")
+    ).upper()
+    
+    create_dirs_prompt = ask_question("Criar subpastas de apoio (scripts, examples, resources, references)? (sim/não)", default="não").lower()
+    create_subdirs = create_dirs_prompt in ['s', 'sim', 'y', 'yes']
+
+    # Criando diretórios e arquivos
+    os.makedirs(target_skill_dir, exist_ok=True)
+    
+    skill_md_path = os.path.join(target_skill_dir, "SKILL.md")
+    
+    # Capitaliza as palavras do nome da skill para o título
+    title_display = " ".join(word.capitalize() for word in skill_name.split("-"))
+    
+    skill_content = f"""---
+name: {skill_name}
+description: {description}
+version: "{version}"
+priority: {priority}
+---
+
+# {title_display}
+
+## Objetivo
+
+Descreva detalhadamente o objetivo e o escopo operacional desta skill.
+
+## Diretrizes de Uso
+
+- Regra 1: Defina como o agente deve agir ao executar esta skill.
+- Regra 2: Seja cirúrgico e prefira simplicidade.
+
+## Exemplos / Referências
+
+Adicione exemplos de prompt ou referências úteis de código aqui.
+"""
+
+    with open(skill_md_path, 'w', encoding='utf-8') as f:
+        f.write(skill_content)
+        
+    print_colored(f"\n[CRIADO] {os.path.relpath(skill_md_path, workspace_root)}", COLOR_GREEN)
+    
+    if create_subdirs:
+        subdirs = ["scripts", "examples", "resources", "references"]
+        for sd in subdirs:
+            sd_path = os.path.join(target_skill_dir, sd)
+            os.makedirs(sd_path, exist_ok=True)
+            # Cria um gitkeep para que as pastas vazias possam ser commitadas
+            gitkeep_path = os.path.join(sd_path, ".gitkeep")
+            with open(gitkeep_path, 'w') as f:
+                pass
+            print_colored(f"[CRIADO] {os.path.relpath(sd_path, workspace_root)}/", COLOR_GREEN)
+            
+    print_colored(f"\n✅ Skill '{skill_name}' criada com sucesso na governança do workspace!", COLOR_GREEN + COLOR_BOLD)
+    print_colored(f"Caminho: {target_skill_dir}\n", COLOR_BLUE)

okam-0.2.0.dist-info/METADATA

@@ -0,0 +1,134 @@
+Metadata-Version: 2.4
+Name: okam
+Version: 0.2.0
+Summary: Framework de governança de IA, memória persistente e gestão de conhecimento
+Author: Juliano Ceconi
+License: MIT
+License-File: LICENSE
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+
+<div align="center">
+
+# ⬡ Okam
+
+**Pare de Redescobrir. Comece a Governar.**
+
+Framework open-source para governança de IA, memória persistente e gestão de conhecimento.
+
+[![MIT License](https://img.shields.io/badge/Licença-MIT-blue.svg)](./LICENSE)
+[![Python 3.8+](https://img.shields.io/badge/Python-3.8+-green.svg)](https://python.org)
+[![PRs Welcome](https://img.shields.io/badge/PRs-Welcome-brightgreen.svg)](https://github.com/juliano-ceconi/okam/pulls)
+
+</div>
+
+---
+
+## O Que É Isso?
+
+**Okam** é um framework que resolve um problema simples: **seus agentes de IA não têm memória.**
+
+Toda vez que você abre uma sessão com seu copilot, ele começa do zero. Sem contexto das decisões passadas, sem governança, sem reutilização de conhecimento.
+
+Okam resolve isso com:
+
+- 🏛️ **Governança** — Regras claras para seus agentes (AGENTS.md + pipeline de 4 fases)
+- 🧩 **Skills** — Capacidades modulares reutilizáveis entre projetos
+- 📚 **Wiki de Conhecimento** — Memória persistente no formato OKF (não é RAG)
+- 🔍 **Pipeline de Metadados** — Extrai a "alma" dos seus projetos automaticamente
+
+## Quick Start (5 minutos)
+
+```bash
+# 1. Clone e instale localmente em modo de desenvolvimento
+git clone https://github.com/juliano-ceconi/okam.git
+cd okam
+pip install -e .
+
+# 2. Inicialize o wiki com seed pages
+okam init
+
+# 3. Customize o AGENTS.md com as regras do seu projeto
+# (edite AGENTS.md com suas preferências)
+
+# 4. Valide a conformidade
+okam validate
+
+# 5. Crie uma nova skill interativamente
+okam new-skill
+```
+
+*Nota: O script legado `python knowledge/scripts/okf_manager.py` continua funcionando como um wrapper de compatibilidade.*
+
+Para o guia completo, veja o [QUICKSTART.md](./QUICKSTART.md).
+
+## Conceitos Core
+
+| Conceito | O Que É | Doc |
+|:---|:---|:---|
+| **LLM Wiki** | Memória persistente vs RAG tradicional | [docs/concepts/llm-wiki.md](./docs/concepts/llm-wiki.md) |
+| **OKF** | Formato padronizado de metadados para conhecimento | [docs/concepts/okf-format.md](./docs/concepts/okf-format.md) |
+| **Deep Metadata** | Pipeline de 4 fases para extrair contexto | [docs/concepts/deep-metadata.md](./docs/concepts/deep-metadata.md) |
+| **Guided Tours** | Padrão TOUR.md para onboarding de agentes | [docs/concepts/guided-tours.md](./docs/concepts/guided-tours.md) |
+| **Git Hooks** | Governança automatizada via hooks pre-commit/push | [docs/concepts/git-hooks.md](./docs/concepts/git-hooks.md) |
+
+## Estrutura do Projeto
+
+```
+okam/
+├── .agents/
+│   ├── rules/           # Padrões de governança
+│   ├── skills/          # Capacidades modulares
+│   │   ├── deep-metadata-analysis/
+│   │   ├── knowledge-wiki/
+│   │   └── memory-maintenance/
+│   └── workflows/       # Pipelines de execução
+├── hooks/               # Git hooks portáveis (POSIX sh)
+│   ├── pre-commit       # Validação OKF + detecção de segredos
+│   ├── commit-msg       # Conventional Commits
+│   └── pre-push         # Validação OKF completa
+├── knowledge/
+│   ├── wiki/            # Páginas de síntese (OKF)
+│   ├── raw-sources/     # Fontes brutas
+│   └── scripts/         # Validador OKF
+├── templates/           # Templates reutilizáveis
+├── docs/
+│   ├── concepts/        # Documentação de conceitos
+│   └── diagrams/        # Diagramas Mermaid
+├── landing/             # Landing page
+├── AGENTS.md            # Governança central
+├── QUICKSTART.md        # Guia rápido
+└── LICENSE              # MIT
+```
+
+## Construído Com
+
+- **Python** — Validador OKF (zero dependências, stdlib only)
+- **Markdown** — Documentação e Wiki
+- **YAML** — Metadados estruturados
+
+## Contribuindo
+
+1. Fork o repositório
+2. Crie uma branch para sua feature (`git checkout -b feat/minha-feature`)
+3. Instale os hooks de governança (`okam hooks install`)
+4. Commit suas mudanças (`git commit -m 'feat: adiciona minha feature'`)
+5. Push para a branch (`git push origin feat/minha-feature`)
+6. Abra um Pull Request
+
+## Licença
+
+Este projeto está sob a licença MIT. Veja [LICENSE](./LICENSE) para mais detalhes.
+
+---
+
+<div align="center">
+
+**⬡ Feito por devs, para devs.**
+
+[Landing Page](./landing/index.html) · [Quick Start](./QUICKSTART.md) · [Documentação](./docs/)
+
+</div>

okam-0.2.0.dist-info/RECORD

@@ -0,0 +1,13 @@
+okam/__init__.py,sha256=Zn1KFblwuFHiDRdRAiRnDBRkbPttWh44jKa5zG2ov0E,22
+okam/cli.py,sha256=5-bRTTUKqVr8TQCod2zmpFPE0VSV13bTi3h978SE5o8,12922
+okam/hooks.py,sha256=0WFBJvaWnydLNOd-Y1UCbWzkxuKTFHWaJNz2o6DvC-k,6366
+okam/manager.py,sha256=FPf4SwBPn4TFriHUfWYiHAOVC7bp_R3JO2zbgT0qamI,5549
+okam/skill_creator.py,sha256=Fg9Mbl_zL_me1bn9mHa7oUZHixFVvW1Xy7ByqiF9x1Y,6028
+okam/hooks/commit-msg,sha256=K6JPe8SpywxD-JprJO_GiwZRxyMOKu-dVlg60liwIYw,2490
+okam/hooks/pre-commit,sha256=ga_MH6QrcyPE-IU-abElVs6xfazmcq64_gq-HqtNj18,4967
+okam/hooks/pre-push,sha256=2VFHSF1gMdAHI2V52EXwM-X68oSTobJ5Co7tGz-CtbA,1402
+okam-0.2.0.dist-info/METADATA,sha256=oXeRW9CREduCo9AYTjvh9UHfP0_orGvyQZK5ME8AabI,4801
+okam-0.2.0.dist-info/WHEEL,sha256=mffPy8wBnZQn2VnJUU5jE99KsxaSfiyMHV9Yt0aLVxs,87
+okam-0.2.0.dist-info/entry_points.txt,sha256=J464ar3O_pbCuxaKrFOUL1H2Z0OqmxwQiq20L63nDI8,39
+okam-0.2.0.dist-info/licenses/LICENSE,sha256=X_SoMbZ6BaV_Mq5UcrmXbHumMxVqOPpF0-kXZ_DRqbs,1074
+okam-0.2.0.dist-info/RECORD,,

okam-0.2.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.30.1
+Root-Is-Purelib: true
+Tag: py3-none-any

okam-0.2.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+okam = okam.cli:main

okam-0.2.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Okam Contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.