Skip to content
Back to search

assistente-executivo

MarketplaceWorks with Claude CodeGitHub

Modelo de assistente executivo com Claude Code: skills, base de conhecimento e processo, pronto para clonar

Safety scan

A static text scan, not a guarantee. Select the badge to see what was scanned and every finding.

Checked today

Check it deeper on your machine

It has changed since its scan on 20 Nov 2026. Its scripts were only partly scanned.

As a Claude Code plugin, install it and then ask Claude Code:

/plugin marketplace add keithmackay/mackayi/plugin install scanskillsafety@mackayiDo a deep scan of https://github.com/fabianoneumann/assistente-executivo with scanskillsafety

Or from a terminal, clone it and run it:

git clone https://github.com/keithmackay/scanskillsafety-skill ~/.claude/skills/scanskillsafetynode ~/.claude/skills/scanskillsafety/cli.cjs --deep 'https://github.com/fabianoneumann/assistente-executivo'

It checks the exact commit: every file, its packages against OSV (api.osv.dev), how it compares with this page's scan (findsafeskills.com receives the repository's address), and, if you agree, Claude reading every file with your own Claude subscription. It never runs the code.

Badge for your README
findsafeskills safety rating

Markdown

[![findsafeskills safety rating](/api/listings/fabianoneumann--assistente-executivo/badge.svg)](/listings/fabianoneumann--assistente-executivo)

HTML

<a href="/listings/fabianoneumann--assistente-executivo"><img src="/api/listings/fabianoneumann--assistente-executivo/badge.svg" alt="findsafeskills safety rating" /></a>

Install

What was scanned

The files the safety scan read, as written by the repository's author and shown as plain text. Lines with a finding are marked.

.claude-plugin/marketplace.json · Manifest · 38 lines
  1. {
  2. "name": "assistente-executivo",
  3. "owner": {
  4. "name": "assistente-executivo"
  5. },
  6. "metadata": {
  7. "description": "O ambiente do assistente executivo como plugin: as treze skills e os dois agentes deste repositório, para instalar noutro projeto.",
  8. "version": "0.1.0"
  9. },
  10. "plugins": [
  11. {
  12. "name": "assistente-executivo",
  13. "source": "./",
  14. "description": "Skills de captura de ideia, revisão, apuração, pesquisa, imagem, bucket R2 a família de produção de peças para o Instagram e o kit de projeto de software novo. As com chave só rodam depois de configurada a chave de quem usa (ver README).",
  15. "version": "0.1.0",
  16. "strict": false,
  17. "skills": [
  18. "./.claude/skills/idea-capture",
  19. "./.claude/skills/review",
  20. "./.claude/skills/story-angle",
  21. "./.claude/skills/research",
  22. "./.claude/skills/image-gen",
  23. "./.claude/skills/r2-storage",
  24. "./.claude/skills/piece-creation",
  25. "./.claude/skills/piece-script",
  26. "./.claude/skills/base-enrichment",
  27. "./.claude/skills/visual-form",
  28. "./.claude/skills/object-anatomy",
  29. "./.claude/skills/slides-export",
  30. "./.claude/skills/project-kit"
  31. ],
  32. "agents": [
  33. "./agents/base-enrichment.md",
  34. "./agents/object-anatomy.md"
  35. ]
  36. }
  37. ]
  38. }
README.md · README · 157 lines
  1. # Assistente executivo
  2. Um modelo de ambiente para trabalhar com o Claude como assistente executivo e pessoal, pronto para usar: um `CLAUDE.md` que diz ao Claude como trabalhar aqui, uma base de conhecimento de método (`knowledge/`), as decisões com o porquê (`decisions/`), treze skills (da captura de uma ideia à peça exportada para o Instagram, mais o kit que faz nascer um projeto de software novo já com o processo) e as pastas da vida pessoal (`finance/`, `health/` e `maps/`), com o método e sem nenhum dado.
  3. É para quem quer um assistente que acumula contexto em arquivos, em vez de redescobrir tudo a cada conversa (o padrão LLM Wiki), e não quer montar tudo do zero. Funciona para uma pessoa só, no trabalho e na vida pessoal.
  4. > **O curso.** O curso *Engenharia de Agentes de IA* ensina a construir o seu próprio ambiente do zero, por prompts, e usa este repositório como gabarito: você monta o seu, compara com este e entende o porquê de cada regra. Quem só quer o ambiente pronto pode usar este modelo direto.
  5. ## Comece por aqui: crie o seu repositório, privado
  6. 1. No GitHub, clique em **Use this template** > **Create a new repository**.
  7. 2. Em **visibility**, escolha **Private**. É o seu repositório que vai guardar a sua voz, as suas ideias e, se você usar a parte pessoal, as suas finanças, a sua saúde e os seus mapas. **Escolha Private antes de pôr qualquer dado pessoal.** Se você já criou como público, mude em Settings > General > Danger Zone > Change repository visibility antes de escrever o primeiro registro: o histórico do git guarda o que foi commitado, mesmo depois de apagado.
  8. 3. Siga um dos dois caminhos abaixo: o de quem programa (o Claude Code no terminal) ou o de quem não programa (a aba Code do app do Claude, sem terminal).
  9. Depois, o `scripts/confere_dados.py` ajuda a manter assim: rodado antes do push, com o `gh` instalado e logado, ele para quando há registro pessoal e o remoto do GitHub é público, e diz como deixar o repositório privado. Ele não roda sozinho (não há hook) e nada confere antes do primeiro registro. Sem o `gh`, ou sem o login dele, sai com o código 3 ("não conferiu") e diz o que falta: a visibilidade no momento da criação é com você.
  10. **Trabalho e vida pessoal no mesmo repositório, ou em dois?** O modelo é um só, com as duas partes. Se você vai dividir o repositório com outras pessoas (um sócio, uma equipe), crie dois a partir deste modelo: um de trabalho, compartilhado, e um pessoal, só seu. A visibilidade e os colaboradores valem para o repositório inteiro.
  11. ## Antes de ligar: revise as skills
  12. Uma skill é instrução que o Claude segue com as suas permissões, nos seus repositórios e com as suas chaves. O Jev, citado em algumas, é o modelo de decisão da TypeSafe (opcional, pago, com a `TYPESAFE_API_KEY`); sem ele, as skills rodam igual. Leia o `SKILL.md` de cada uma antes de usá-la, e reescreva o que não serve a você; os termos do método que elas usam (mesa, portão, trava do texto, escaleta, I2) estão explicados no [`glossario.md`](./glossario.md). O que é do seu ambiente (caminhos, réguas, comandos, a regra de custo das APIs) está no `references/projeto.md` de cada skill; o método, no `SKILL.md`; e as lições que viraram regra, no `licoes.md`.
  13. | Skill | O que faz | O que lê | O que pode rodar | Chave |
  14. |---|---|---|---|---|
  15. | `idea-capture` | registra uma ideia crua em `marketing/social-media/ideas/`, sem perguntar, pesquisar nem propor ângulo | os arquivos de `ideas/` | nada | nenhuma |
  16. | `review` | revisão independente por lentes: um agente acha os problemas, outro confere cada achado, sai a lista dos confirmados, sem alterar o trabalho | o trabalho e as fontes dele, as réguas, a issue ou o PR | `gh` (ler issues e PRs); o Codex e o Jev, opcionais | nenhuma (o `gh` com o seu login); opcional: `TYPESAFE_API_KEY` |
  17. | `story-angle` | apura um tema por movimentos jornalísticos até uma mesa de ângulos; a escolhida vira pauta no arquivo da ideia | `context/publico.md`, `knowledge/`, `ideas/` | as buscas vão pela `research` | nenhuma própria |
  18. | `research` | pesquisa com fontes (Perplexity, Gemini, busca nativa e, opcional, o Codex), reconcilia e registra fichas e sínteses em `knowledge/` | `knowledge/`, `decisions/`, `context/` | a busca web da sessão; com as chaves, as APIs da Perplexity e do Gemini pela rede; scripts locais de conferência | nenhuma no modo só busca nativa; `PERPLEXITY_API_KEY` e `GEMINI_API_KEY` acrescentam índices e o profundo; opcional: `TYPESAFE_API_KEY` |
  19. | `image-gen` | gera imagem pelo Nano Banana (Gemini) e, opcional, pelo GPT Image do Codex, com o banco consultado antes e o custo registrado | o banco de imagens, o design system da série | a API do Gemini; o Codex CLI, opcional; a conferência pelo Jev, opcional | `GEMINI_API_KEY`; opcional: `TYPESAFE_API_KEY` |
  20. | `r2-storage` | sobe, baixa, lista e remove arquivos num bucket R2 da Cloudflare e dá a URL pública ou assinada | as variáveis `R2_*` | a API S3 do R2 pela rede | `R2_ACCOUNT_ID`, `R2_ACCESS_KEY_ID`, `R2_SECRET_ACCESS_KEY`, `R2_BUCKET_CONTEUDO` (a URL pública, `R2_PUBLIC_BASE_CONTEUDO`, opcional aqui e obrigatória no `--upload`) |
  21. | `piece-creation` | leva uma peça (carrossel, Stories) da ideia ou da pauta até a exportação, chamando as outras na ordem, com as paradas para você decidir | as ideias, a série, as rubricas, o portão, `context/publico.md` | nada próprio; cada skill chamada confere a sua chave | nenhuma própria (a partir da ideia crua, a pesquisa roda no modo só busca nativa; as chaves da `research` acrescentam índices) |
  22. | `piece-script` | escreve o roteiro da peça por formato até a trava do texto | a pauta, as fichas, as sínteses de conteúdo, as rubricas | nada | nenhuma |
  23. | `base-enrichment` | num subagente isolado, passa pela base sobre uma camada da peça e devolve até cinco sugestões de método | `knowledge/`, as peças irmãs, `marketing/licoes.md` | só grava o relatório dela | nenhuma |
  24. | `visual-form` | monta o HTML das telas no design system da série, com as conferências em código, até a prévia | o texto travado, a escaleta, o design system da série | Playwright (Chromium) e FFmpeg, locais | nenhuma |
  25. | `object-anatomy` | num subagente, faz o objeto que se move em SVG por código, com as conferências por script | as fichas que quem chama entrega, a série | Playwright e FFmpeg, locais | nenhuma |
  26. | `project-kit` | cria um projeto de software novo já estruturado: a discussão inicial, a arquitetura, o plano e os ADRs na base `knowledge/` do projeto, o repositório montado dos modelos (o processo de issues e de PR, o CI, o Dependabot de segurança, as travas, o onboarding) e conferido, e o GitHub com a primeira milestone e as specs, na sua conta pessoal | a conversa, os modelos da skill, `knowledge/software-engineering/` | `git`, Python (com o PyYAML e o Playwright do `requirements.txt` dela, para a conferência e os diagramas) e o `gh` (criar o repositório, a milestone e as specs) | nenhuma (o `gh` com o seu login) |
  27. | `slides-export` | exporta as telas em JPEG e a tela em vídeo em MP4, confere e, com `--upload`, sobe ao bucket e registra os links | as telas, a `legenda.md`, `context/sobre-mim.md` | shot-scraper, Playwright e FFmpeg; com `--upload`, o R2 | só para `--upload`: as do `r2-storage` |
  28. **O ciclo de melhoria da `review` só liga com a issue de reavaliação aberta:** sem ela, a revisão roda mas não deixa registro, e você não mede se a skill está ajudando. Quando quiser medir, abra a issue e ponha o número no `references/projeto.md` da skill. A issue junta, a cada revisão, um comentário de uma linha com os números daquele uso (o que se revisou, as lentes, os achados confirmados e derrubados, o que se aplicou, o que a revisão deixou passar e os tokens) e, a partir do 15º registro ou na data de vencimento dela, a proposta de reavaliar a skill com esses números (`.claude/skills/review/references/registro.md`). O que você ensina ao assistente sobre como trabalhar fica na memória dele, com cópia opcional no git (`decisions/memoria-e-evolucao.md`).
  29. **Sem chave nenhuma, funcionam desde o clone:** `idea-capture`, `review`, `piece-script`, `base-enrichment` e a `research` no modo só busca nativa, e a `project-kit` com o `gh` logado; `visual-form`, `object-anatomy` e a exportação local da `slides-export` pedem só os programas locais. **A pesquisa sem chave:** sem a `PERPLEXITY_API_KEY` e a `GEMINI_API_KEY`, a `research` roda no **modo só busca nativa**: busca pela busca web da sessão do Claude Code, verifica na fonte primária como no modo completo e registra o modo na rodada e na síntese, porque a triangulação é menor (um índice só) e não há o modo profundo. As duas chaves acrescentam índices e o profundo. **Sem chave própria, mas dependem de outra:** a `story-angle` apura pela `research` e a `piece-creation` chama a `research`, a `image-gen` e a `slides-export`, cada uma com a sua. Por isso a apuração e o carrossel feito a partir de uma ideia crua, que passa pela apuração e pela pesquisa antes do roteiro, funcionam desde o clone, no modo só busca nativa; as chaves da `research` acrescentam índices. **As outras com chave não rodam antes de você configurar a sua:** o primeiro passo de cada uma confere, e sem a chave ela para e diz qual variável falta, onde se pega e como se põe. As APIs são cobradas à parte do plano do Claude: antes de usar, preencha a regra de custo das suas contas no `references/projeto.md` da `research` e da `image-gen`.
  30. **A vida pessoal não pede skill nem chave:** é o `CLAUDE.md` que diz ao assistente onde lançar uma despesa, um treino, um exame ou um mapa, e os READMEs de `finance/`, `health/` e `maps/` trazem o método e o roteiro do que contar a ele para começar.
  31. Não vêm nesta versão: a publicação no Instagram e as métricas (dependem de uma conta da Meta e de rotinas agendadas). A sua série de posts nasce da série de exemplo em branco (`marketing/social-media/carousels/series/exemplo/`).
  32. ## Caminho 1: quem programa (Claude Code)
  33. 1. **O que instalar:** o [Claude Code](https://code.claude.com/docs) (ou o app do Claude, aba Code), o Git e o Python 3.11 ou mais novo. Para as skills de forma e exportação, também o FFmpeg e o Chromium do Playwright (abaixo). O `gh` (GitHub CLI) serve à `review`, à `project-kit` e à conferência de privacidade do `confere_dados.py`.
  34. 2. **Clonar o seu repositório e abrir:**
  35. ```
  36. git clone <endereço do seu repositório> assistente-executivo
  37. cd assistente-executivo
  38. claude
  39. ```
  40. Na primeira vez, o Claude Code pergunta se você confia na pasta: aceite, depois de ter lido as skills. O `CLAUDE.md` e as skills de `.claude/skills/` carregam sozinhos.
  41. 3. **Ver o que falta:** `python -X utf8 scripts/confere_ambiente.py`. Ele mostra, skill por skill, o que já funciona e o que falta, sem nunca mostrar o valor de uma chave.
  42. 4. **Pôr as suas chaves** (só as das skills que você vai usar):
  43. ```
  44. python -X utf8 scripts/prepara_chaves.py --skill research
  45. ```
  46. Ele cria o `.env` a partir do `.env.example`, só se o `.env` ainda não existir (nunca sobrescreve, e não lê nem mostra um que já existe), e diz em que linha fica cada variável da skill que você passou (sem `--skill`, só cria). Abra o `.env` no seu editor e troque o marcador `COLE_...` pelo valor. Cada linha do `.env.example` diz para que serve a chave e onde se pega; linha que fica com o marcador conta como não configurada. O `.env` nunca vai ao git (`.gitignore`). O `.claude/settings.json` nega à ferramenta de leitura do Claude o `.env`, o `.env.local` e o `.claude/settings.local.json`, mas um comando de terminal não é barrado por isso: não peça ao Claude para abrir, mostrar ou procurar dentro desses arquivos, e não cole chave na conversa, nem em nenhum arquivo versionado. Quem lê as chaves são os scripts das skills.
  47. O `.env` é o caminho recomendado. A alternativa é o bloco `"env"` do `.claude/settings.local.json`, que também fica fora do git e que o Claude Code carrega como variáveis de ambiente da sessão: `python -X utf8 scripts/prepara_chaves.py --settings --skill research` o cria a partir do `.claude/settings.local.example.json`, com as mesmas variáveis e os mesmos marcadores do `.env.example`. Se o `settings.local.json` já existir (o Claude Code o cria ao guardar uma permissão que você aceitou), o script não mexe nele: copie o bloco `"env"` do exemplo para dentro dele, no seu editor. O JSON não aceita comentário, e o exemplo não leva campo de explicação, porque não confirmamos que o Claude Code aceita chave fora do esquema dele: a explicação fica aqui e no `.env.example`. Os dois caminhos funcionam no terminal e no Code do app desktop (testado em 19/11), e o `.claude/settings.json` nega a leitura dos dois ao Claude. Quando a mesma variável está nos dois, vale a do `settings.local.json`.
  48. Depois, reinicie a sessão e rode o passo 3 de novo.
  49. 5. **Instalar os pacotes Python** das skills que você vai usar (o `confere_ambiente.py` diz quais faltam):
  50. ```
  51. python -m pip install -r .claude/skills/research/requirements.txt
  52. python -m pip install -r .claude/skills/image-gen/requirements.txt
  53. python -m pip install -r .claude/skills/r2-storage/requirements.txt
  54. python -m pip install -r .claude/skills/visual-form/requirements.txt
  55. python -m pip install -r .claude/skills/project-kit/requirements.txt
  56. python -m playwright install chromium
  57. shot-scraper install
  58. ```
  59. O FFmpeg (vídeo das telas e quadros) se instala à parte: no Windows, `winget install Gyan.FFmpeg`; no macOS, `brew install ffmpeg`; ou pelo site [ffmpeg.org](https://ffmpeg.org/download.html).
  60. 6. **Preencher o contexto:** `context/sobre-mim.md` (quem você é e a sua voz ao escrever conteúdo) e `context/publico.md` (para quem você fala) vêm em branco, com o roteiro. Sem eles, o assistente pergunta em vez de inventar.
  61. 7. **Primeiro uso:** peça em linguagem natural, como "registra uma ideia: …", "pesquisa o que existe sobre …", "lança uma despesa de …" ou "vamos fazer a minha Roda da Vida". O Claude escolhe a skill pela descrição dela, e o lugar de cada registro pelo `CLAUDE.md`.
  62. **Antes de commitar** material que veio de fora, e sempre antes do push: `python -X utf8 scripts/confere_dados.py` procura chave, e-mail, telefone, caminho de usuário, id de conta e conteúdo de terceiro fora da régua no que iria num commit (o que o `.gitignore` tira, como o `.env` e as pastas `originals/`, fica fora), confere a privacidade do repositório e, rodado sem pastas, o autor de cada commit do histórico: o seu e-mail real sai como achado; no repositório privado, você pode deixá-lo, ou usar o e-mail `noreply` do GitHub (Settings > Emails). Com `--termos <arquivo fora do repositório>`, procura também os nomes e ids que você quer barrar (de clientes, de familiares), sem que a lista entre no git.
  63. ### Para conferir que está tudo certo
  64. Da raiz do repositório, no começo e depois de instalar os pacotes. Nenhum destes comandos pede rede nem chave, e nenhum mostra o valor de uma chave.
  65. | Comando | O que confere | O esperado |
  66. |---|---|---|
  67. | `python -X utf8 scripts/confere_ambiente.py` | skill por skill, o que já roda e o que falta | código 0, com o quadro: "pronta" nas skills que você configurou e "falta configurar" nas outras, com o que falta (a `research` sem as chaves sai "pronta no modo só busca nativa"); no alto, de onde vieram as chaves (o `.env` ou a variável do sistema) |
  68. | `python -X utf8 scripts/confere_links.py` | os links entre os arquivos e as duas cópias dos agentes | `-- 0 link(s) quebrado(s)` |
  69. | `python -X utf8 scripts/confere_dados.py` | chave, dado pessoal e conteúdo de terceiro no que iria num commit | `-- 0 achado(s)` e código 0; o seu e-mail real nos commits sai como achado (ver "Antes de commitar", acima) |
  70. | `python -X utf8 scripts/teste_confere_dados.py` | os casos do `confere_dados.py` | `TODOS OK` |
  71. | `python -X utf8 scripts/teste_medir_disparo.py` | os casos do `medir_disparo.py` | `TODOS OK` |
  72. | `python -X utf8 scripts/teste_prepara_chaves.py` | os casos do `prepara_chaves.py`, numa pasta temporária | `TODOS OK` |
  73. | `python -X utf8 .claude/skills/research/scripts/teste_conferidores.py` | as conferências das rodadas de pesquisa, sem chamar as APIs | `0 falha(s)`, com as lacunas conhecidas listadas, que não derrubam o teste |
  74. | `python -X utf8 .claude/skills/review/scripts/teste_registro.py` | a contagem do registro da `review`, sem o `gh` | `0 falha(s)` |
  75. | `python -X utf8 -m unittest discover -s .claude/skills/project-kit/scripts -p "teste_*.py"` | a montagem e a conferência de um projeto novo, nas três stacks (pede o `requirements.txt` da `project-kit`) | `Ran 8 tests` e `OK` (as linhas "Montado em ...", que podem vir antes ou depois, são da montagem) |
  76. | `python -X utf8 .claude/skills/project-kit/scripts/teste_diagrama_conferir.py`, e o mesmo com `teste_diagrama_regressao.py` no lugar | os diagramas do onboarding (pedem o Playwright com o Chromium) | `tudo certo` em cada um |
  77. Se um deles falhar, a saída diz o que falta ou o que quebrou; o mais comum, no começo, é um pacote não instalado (o `confere_ambiente.py` diz qual e o `requirements.txt` de onde ele vem).
  78. ### O Codex, opcional
  79. Quem usa também o Codex CLI (da OpenAI) acha as instruções do projeto pelo [`AGENTS.md`](./AGENTS.md), que só manda ler o `CLAUDE.md`, a fonte única. Na `review`, o Codex entra como **segunda revisão de código**, ao lado do `/code-review` do Claude Code e sem substituí-lo:
  80. 1. instale o [Codex CLI](https://developers.openai.com/codex/cli) e entre com `codex login`;
  81. 2. crie uma vez o perfil só leitura em `~/.codex/revisao.config.toml`, com `sandbox_mode = "read-only"`, `approval_policy = "never"` e, numa seção `[features]`, `apps = false`;
  82. 3. a `review` monta uma pasta isolada, na pasta temporária, só com os arquivos revisados, e roda `codex exec --skip-git-repo-check --ephemeral -p revisao -C <pasta isolada> -o <achados.md> - < <pedido>`.
  83. Os achados do Codex entram na mesma conferência que os do `/code-review`. Sem o Codex, a revisão segue e diz que ele não rodou. O detalhe está em `.claude/skills/review/references/codigo.md`.
  84. ### As skills noutro projeto (o plugin)
  85. O repositório é também um marketplace com o plugin `assistente-executivo`, que leva as treze skills e os dois agentes. Os agentes ficam em dois lugares: `.claude/agents/`, que o Claude Code lê no clone, e `agents/`, na raiz, que o plugin leva, porque declarados a partir da `.claude/` eles não carregam. As duas cópias são iguais, e o `scripts/confere_links.py` acusa quando divergem: quem muda um agente muda os dois. Noutro projeto:
  86. ```
  87. claude plugin marketplace add <caminho do clone, ou dono/repositório no GitHub>
  88. claude plugin install assistente-executivo@assistente-executivo
  89. ```
  90. No plugin, as skills ganham o prefixo (`/assistente-executivo:research`). Elas esperam a estrutura deste repositório (`knowledge/`, `marketing/`, `context/`, `scripts/confere_ambiente.py`); num projeto sem ela, o método vale, os caminhos não, e a conferência de chave fica a cargo do próprio código de cada skill, que para com a mesma mensagem. Não instale o plugin dentro deste repositório: as skills já carregam de `.claude/skills/`, e ficariam em dobro.
  91. ## Caminho 2: quem não programa (o Code, no app do Claude)
  92. O app do Claude no computador tem a aba **Code**, que trabalha numa pasta do seu computador sem você abrir o terminal: é o mesmo Claude Code do caminho 1, numa janela. Para trabalhar com os arquivos de uma pasta, é o caminho que a Anthropic recomenda hoje (o Cowork, que fazia isso antes, foi fundido à conversa do app). Num teste de 19/11, numa cópia deste repositório, o Code do app desktop fez o que o caminho 1 faz: ao escolher a pasta, pediu para confiar nela; leu sozinho o `CLAUDE.md` como instrução; carregou as skills de `.claude/skills/`, que dispararam, e os agentes de `.claude/agents/`; rodou o aviso de início de sessão; recusou sozinho, sem pedir aprovação, a leitura do `.env` e do `.claude/settings.local.json`; leu as chaves dos dois arquivos; rodou o Python e chegou à rede.
  93. 1. **O que precisa:** uma conta paga do Claude (Pro, Max ou acima) e o app do Claude no computador (Windows ou macOS), em [claude.ai/download](https://claude.ai/download).
  94. 2. **Trazer o seu repositório para o computador.** O jeito mais simples é o [GitHub Desktop](https://desktop.github.com/): entre com a sua conta do GitHub, vá em File > Clone repository, escolha o repositório que você criou pelo **Use this template** e a pasta onde ele vai ficar. Assim, o que você gravar volta ao GitHub pelo próprio GitHub Desktop. Outro jeito: crie uma pasta vazia, escolha-a no passo 3 e peça ao agente "clona aqui o meu repositório", com o link dele; se faltar o Git ou o login do GitHub, ele diz o que falta e ajuda.
  95. 3. **Abrir a pasta no Code:** no app, abra a aba **Code**, escolha o ambiente "This computer" e a pasta do repositório (pode estar em outro disco). O app pergunta "Trust this workspace?" e lista o `.claude/settings.json` como o que pode rodar código: confie depois de ter lido as skills (acima). O modo de permissão vem em "Auto".
  96. 4. **Pedir ao agente o que faltar:** peça "confere o ambiente com o `scripts/confere_ambiente.py` e instala o que faltar". Se o Python não estiver instalado, o agente o instala antes, e depois os pacotes que o script apontar (o caminho 1 lista quais são, no passo 5).
  97. 5. **As chaves:** peça "cria o arquivo de chaves da research com o `scripts/prepara_chaves.py`" (troque `research` pela skill que você vai usar). Ele cria o `.env`, só se ainda não existir, e diz em que linha fica cada variável. Abra o `.env` num editor de texto (o Bloco de Notas serve) e troque o marcador `COLE_...` pelo valor; cada linha do arquivo diz para que serve a chave e onde se pega. Não cole a chave na conversa: o agente não consegue ler esse arquivo, e é assim que deve ser. Quem lê as chaves são os scripts das skills. Depois, comece uma sessão nova. (O bloco `env` do `.claude/settings.local.json` também funciona, ver o passo 4 do caminho 1.)
  98. 6. **Preencher o contexto:** `context/sobre-mim.md` e `context/publico.md` vêm em branco, com o roteiro. Peça ao agente para fazer as perguntas do roteiro e preencher com você.
  99. 7. **Usar:** peça em linguagem natural ("registra esta ideia", "revisa este texto", "pesquisa o que existe sobre …", "lança o que gastei hoje"). Antes de mandar ao GitHub, peça ao agente para rodar o `scripts/confere_dados.py` (ver "Antes de commitar", no caminho 1).
  100. O que o caminho 1 diz das skills, das chaves e das conferências vale aqui: é o mesmo programa. As conferências da tabela "Para conferir que está tudo certo" o agente roda por você.
  101. **Acompanhar pelo celular:** o app desktop tem o Remote Control, que permite acompanhar pelo celular uma sessão aberta no computador. Ainda não testamos esse uso aqui: conte com ele como possibilidade.
  102. **Aviso para quem usa o assistente no e-mail e na agenda:** o Gmail e a Agenda pelos conectores da conta (Customize > Connectors) foram testados dentro do Code em 19/11: enviaram e-mail, criaram e apagaram evento. No modo de permissão "Auto", que é o padrão, essas ações aconteceram sem pedir confirmação: o agente enviou o e-mail e criou ou apagou o evento sem perguntar antes. Para exigir a confirmação, ligue "Always ask" nas ferramentas do conector (a de enviar, a de criar e a de apagar), ou use um modo de permissão que pergunte antes de agir. Se um plugin instalado trouxer um conector próprio de agenda ou de e-mail que falha, reconectar o conector da conta (Customize > Connectors) resolveu no teste.
  103. **Ainda por testar, antes de contar com isso:**
  104. - o caminho pela conversa do app (o chat), sem pasta, com as skills instaladas na sua conta pelo ZIP do `scripts/empacota_skills.py` (Customize > Skills): fica para depois.
  105. ## A vida pessoal
  106. As pastas `finance/`, `health/` e `maps/` vêm com o README do método e o roteiro do que preencher, e nenhum registro: o arquivo de cada coisa (o mês das finanças, o plano de treino, o exame, o retrato de um mapa) nasce quando você contar a primeira informação dele. Os mapas sugeridos, cada um com um guia curto em `maps/guides/`: Vision Board, Roda da Vida, Big Five (pelo IPIP-NEO-120, de domínio público), SWOT, Ikigai, Matriz EREC e OKR. O quadro `maps/board/` abre no seu navegador, com os modelos em branco, e não se publica em link.
  107. O assistente não diagnostica, não estima personalidade pela conversa e sugere o profissional quando o assunto pede. O porquê está em [`decisions/vida-pessoal-e-mapas.md`](./decisions/vida-pessoal-e-mapas.md).
  108. ## A base de conhecimento
  109. A `knowledge/` traz 89 sínteses de método, por área (avaliação e revisão por agentes, design de conteúdo, mídia gerada, apuração, dados, psicologia, o Claude Code, vendas, engenharia de software), e 463 fichas de fonte. Num repositório público, nenhuma ficha traz o texto integral da fonte: as de licença livre e as de fonte protegida vêm em palavras próprias, com citações curtas, e o integral se lê na fonte, pelo link. As três fichas livres que ainda têm trecho colado à fonte vêm só como citação simples (o título, o autor, o link e a licença). A régua está em [`knowledge/sources/README.md`](./knowledge/sources/README.md).
  110. ## A licença
  111. O código é MIT ([`LICENSE`](./LICENSE)); o texto é CC BY 4.0 ([`LICENSE-texto`](./LICENSE-texto)). O material de terceiro segue a licença dele, e as 17 fichas de fontes em CC BY-SA são exceção declarada, na licença da fonte (a lista está no `LICENSE-texto`).
  112. ## Como o repositório se organiza
  113. O mapa do que ler, e quando, está no [`index.md`](./index.md); as regras de manutenção, no [`CLAUDE.md`](./CLAUDE.md); os termos do método, no [`glossario.md`](./glossario.md). Em resumo: `context/` (quem você é e para quem fala), `decisions/` (o porquê das regras), `knowledge/` (a base de método, com as fontes e a régua de conteúdo de terceiro), `marketing/` (ideias, séries, rubricas), `finance/`, `health/` e `maps/` (a vida pessoal), `partners/` (os parceiros e os clientes, com o modelo em branco dos documentos; só em repositório privado), `.claude/skills/` (as skills) e `scripts/` (os conferidores e o empacotador).
.claude/skills/visual-form/scripts/medidas_forma.py · Bundled script · 536 lines · 1 finding marked
  1. """Os AVISOs de forma do conferir_telas.py que pedem olhar, todos provisórios até calibrar com peças rotuladas da série:
  2. nenhum barra o --upload. Cada limiar diz de onde saiu; os de partida se trocam pelos da série no design/papeis.json.
  3. - papel_fora_da_tabela: o corpo, a entrelinha e o peso computados de cada bloco com classe de papel contra a tabela
  4. "Letra" do design system da série (o design/papeis.json; a nota no corpo da chamada é a chamada), no papel da tela
  5. (tipo-a ou tipo-b), com 1 px de tolerância; e mais de um tamanho por papel na mesma tela. Só no carrossel da série
  6. (tipo-a, tipo-b; nos Stories o corpo tem a faixa própria do README). O desvio declarado no refinamentos.md também
  7. dispara, e deve: o aviso sai com o desvio ao lado, para a leitura.
  8. - corpo_sem_negrito (por peça): a fração das telas com corpo ou item de lista que levam algum negrito abaixo de 25%.
  9. Por bloco não separa (um corpo longo sem negrito pode estar certo), por isso a conta é da peça; e só a partir de
  10. quatro telas com corpo, porque com menos a conta não diz nada.
  11. - acento_area: a fração dos pixels perto da cor do acento que a série declara (com um filtro de croma), na tela com as
  12. fotos e imagens escondidas e as linhas do papel fora. Por peça, a média abaixo do piso avisa (falta a marca à mão);
  13. por tela, acima do teto (cor quente em área demais). Os pontos de partida, 0,41% e 1,4%, se trocam pelos medidos nas
  14. publicadas da série ("limiares" no papeis.json). Sem a cor declarada, não roda.
  15. - imagem_ja_publicada: o SHA-256 de cada imagem da tela (img e url() de fundo) contra as das peças publicadas, só as
  16. que moram na pasta da peça publicada (o kit da série, fora das pastas das peças, não conta): nenhum desenho repetido
  17. de uma peça publicada sem o motivo dito.
  18. - texto_fora_do_travado: as palavras visíveis de cada tela (fora a moldura e a palavra riscada da correção) contra as
  19. da tela no texto.md travado; um aviso por tela, com o que entra e o que sai. "Ajuste de forma não troca palavra do
  20. texto aprovado."
  21. - ponta_da_seta (toda linha termina em algo; a ponta da seta entra no alvo, de 20 a 30 px): a ponta de cada seta livre
  22. do desenho (path.seta-livre) que não cai nem encosta (12 px) em nenhum alvo (forma do svg que não é seta, foto,
  23. imagem, folha que espia) nem fica perto de texto (40 px) termina no vazio; a seta de anotação (a que sai de uma nota,
  24. rótulo ou legenda) que cai num alvo largo e entra menos de 20 px, mal entra. O conector entre dois desenhos só
  25. precisa encostar. O alvo se mede pela caixa, então a profundidade é aproximada: é aviso, e o zoom das juntas
  26. (juntas.py, da object-anatomy) mostra a ponta a 4×.
  27. - Na legenda, só na exportação: caractere_invisivel (espaço de largura zero, hífen suave, marca de direção, caractere
  28. de tag, espaço sem quebra) e primeira_frase_legenda, a primeira frase que passa do corte do feed (cerca de 125
  29. caracteres, número aproximado e ainda sem fonte que o confirme). Avisa a partir de 110: a margem de 15 é de partida,
  30. a calibrar. A fonte fala da primeira linha; o código mede a primeira frase (até o primeiro ponto ou a primeira
  31. quebra), no lugar dela.
  32. - cor_fora_dos_tokens (D3) e itens_por_grupo (D4), só nas telas da série: a cor computada (texto, fundo, borda, traço e
  33. preenchimento do svg) fora das cores das propriedades --* da página, com a imagem e a foto colada (.foto) fora; e a
  34. lista (ul, ol) com mais de quatro itens, fora as listas que o design system libera (a lista de pendências,
  35. .pendentes, e a linha do tempo, .linha-tempo).
  36. - papeis_por_tela, só nas telas da série: mais de 4 papéis tipográficos de conteúdo na tela (PAPEIS_TETO), pela classe
  37. (CLASSE_PAPEL), com o rótulo (.rot, .leg, a anotação de diagrama), a fonte (.fonte, metadado) e a moldura fora.
  38. Fica de fora, com o motivo: tela_sem_dominante, porque nenhum limiar de altura absoluta separou a tela fraca das boas
  39. (a falta era o traço fino e o tamanho relativo à tela-par, que a I2 lê).
  40. """
  41. import functools
  42. import hashlib
  43. import json
  44. import re
  45. from html import unescape
  46. from pathlib import Path
  47. from urllib.parse import unquote, urlparse
  48. ROOT = Path(__file__).resolve().parents[4]
  49. # O que a série declara para as conferências mora no design/papeis.json dela, ao lado do caderno.css que a página
  50. # carrega, e não aqui: a tabela "Letra" do design system (papel -> corpo no A, entrelinha no A, corpo no B, entrelinha
  51. # no B, peso), a cor do acento e os limiares do acento. O nível do travessão vem da voz de quem usa
  52. # (context/sobre-mim.md, nivel_travessao). O teste_papeis.py confere que a tabela do
  53. # JSON e a do design-system.md dizem o mesmo. Sem o arquivo, nada disso roda (ausente não é zero).
  54. def pasta_do_caderno(post, html="slides.html"):
  55. """A pasta design/ da série, pelo caderno.js ou pelo caderno.css que a própria página carrega; None sem eles."""
  56. p = Path(post) / html
  57. if not p.is_file():
  58. return None
  59. texto = p.read_text(encoding="utf-8")
  60. for m in re.finditer(r'(?:src|href)="([^"]*caderno\.(?:js|css))"', texto):
  61. alvo = (Path(post) / unquote(m.group(1))).resolve()
  62. if alvo.is_file():
  63. return alvo.parent
  64. return None
  65. @functools.lru_cache(maxsize=None)
  66. def _ler_serie(caminho):
  67. return json.loads(Path(caminho).read_text(encoding="utf-8"))
  68. def carregar_serie(post, html="slides.html"):
  69. """O design/papeis.json da série que a página carrega, como dicionário; None sem ele."""
  70. pasta = pasta_do_caderno(post, html)
  71. if pasta is None or not (pasta / "papeis.json").is_file():
  72. return None
  73. return _ler_serie(str(pasta / "papeis.json"))
  74. def papeis_de(serie):
  75. """{papel: (corpo A, entrelinha A, corpo B, entrelinha B, peso)} da série; None sem a tabela."""
  76. if not serie or not serie.get("papeis"):
  77. return None
  78. return {k: tuple(v) for k, v in serie["papeis"].items()}
  79. def carregar_papeis(post, html="slides.html"):
  80. """A tabela "Letra" da série que a página carrega (papeis_de); None sem o papeis.json."""
  81. return papeis_de(carregar_serie(post, html))
  82. def acento_de(serie):
  83. """(r, g, b) da cor do acento que a série declara ("acento": "#RRGGBB"); None sem ela (o acento_area não roda)."""
  84. c = (serie or {}).get("acento")
  85. if not isinstance(c, str) or not re.fullmatch(r"#[0-9A-Fa-f]{6}", c):
  86. return None
  87. return tuple(int(c[i:i + 2], 16) for i in (1, 3, 5))
  88. def limiares_do_acento(serie):
  89. """(piso da peça, teto da tela), em % da área da tela: os que a série declara em "limiares", ou os de partida."""
  90. lim = (serie or {}).get("limiares") or {}
  91. return (float(lim.get("acento_piso_peca", ACENTO_PISO_PECA)), float(lim.get("acento_teto_tela", ACENTO_TETO_TELA)))
  92. # A voz de quem usa pede texto sem travessão? O mesmo critério do voz_pede_sem_travessao() do export_slides.py da
  93. # slides-export (não se importa de lá, porque a exportação importa esta conferência): "sem travessão", "nada de
  94. # travessão", "evite o travessão", "nunca use travessão", "o travessão é proibido"; o roteiro em branco, que só pergunta
  95. # "se o travessão é proibido", não conta. Quem mudar um muda o outro.
  96. VOZ_SEM_TRAVESSAO = re.compile(r"(sem|nada de|evit\w*|(nunca|n[aã]o)( use| usa| usar| uso)?)\s+(o |os |de )?travess"
  97. r"|(?<!se o )travess\w*\s+(é|e|são|sao|fica|ficam)\s+(proibid|fora)", re.I)
  98. def voz_pede_sem_travessao(raiz=ROOT):
  99. """A voz de quem usa (context/sobre-mim.md) pede texto sem travessão? None sem o arquivo."""
  100. arq = Path(raiz) / "context" / "sobre-mim.md"
  101. if not arq.is_file():
  102. return None
  103. return bool(VOZ_SEM_TRAVESSAO.search(arq.read_text(encoding="utf-8")))
  104. def nivel_travessao(serie=None, raiz=ROOT):
  105. """O nível do travessão: ERRO quando a voz de quem usa pede texto sem travessão; senão (sem o arquivo, ou sem a
  106. regra escrita nele), AVISO: a conferência não inventa regra que a voz não tem. `serie` fica pela assinatura."""
  107. return "ERRO" if voz_pede_sem_travessao(raiz) else "AVISO"
  108. # classe -> papel, na ordem em que se decide (a .margem e o .rot são a nota à margem e o rótulo, no corpo da nota)
  109. CLASSE_PAPEL = (("citacao", "citacao"), ("titulo", "titulo"), ("destaque", "destaque"), ("nota", "nota"),
  110. ("margem", "nota"), ("fila", "fila"), ("link", "link"), ("apoio", "apoio"), ("fonte", "fonte"),
  111. ("corpo", "corpo"))
  112. TOL_PAPEL = 1.0
  113. NEGRITO_PISO = 0.25
  114. NEGRITO_MIN_TELAS = 4 # peça com menos telas de corpo não tem conta que diga alguma coisa
  115. ACENTO_RAIO = 60 # distância de cor (soma quadrática dos canais) até a cor do acento da série
  116. ACENTO_PISO_PECA = 0.41 # % da área da tela, média da peça: ponto de partida, a calibrar com as publicadas da série
  117. ACENTO_TETO_TELA = 1.4 # % da área de uma tela: idem
  118. SETA_ENTRA_MIN = 20 # px que a ponta entra no alvo (de 20 a 30)
  119. SETA_TEXTO_PERTO = 40 # px: a ponta perto de uma linha de texto aponta o texto (a sobreposição confere a letra)
  120. SETA_ENCOSTA = 12 # px: a ponta a até isto da caixa de um alvo encosta nele (o conector, a linha fina)
  121. CORTE_LEGENDA = 125 # caracteres antes do "mais" no feed (aproximação do autor; a apurar)
  122. CORTE_MARGEM = 15 # margem de partida (a fonte pede margem sem dar número), a calibrar
  123. INVISIVEIS = re.compile("[​‌‍⁠­‎‏‪-‮⁦-⁩᠎ "
    • Warning: Contains 4 bidirectional-override character(s), which make text display in a different order from how it's read
    • Line 146 on GitHub
  124. "\U000e0000-\U000e007f]")
  125. ESCONDER_FIGURAS = (".slide img,.slide .foto,.slide picture,.slide video,.slide canvas{visibility:hidden!important}"
  126. ".slide .folha-a,.slide .folha-b{background-image:none!important}")
  127. MEDIR_FORMA = r"""(idx) => {
  128. const sl = document.querySelectorAll('.slide')[idx];
  129. const tipo = sl.classList.contains('tipo-a') ? 'a' : sl.classList.contains('tipo-b') ? 'b' : null;
  130. const fora = e => !!e.closest('svg,.sim,[data-adesivo-sim]');
  131. const vis = e => { const r = e.getBoundingClientRect(); const cs = getComputedStyle(e);
  132. return r.width > 1 && r.height > 1 && cs.visibility !== 'hidden' && cs.display !== 'none'; };
  133. const PAPEL = """ + "[" + ",".join(f"['{c}','{p}']" for c, p in CLASSE_PAPEL) + "]" + r""";
  134. const papeis = [];
  135. if (tipo) for (const el of sl.querySelectorAll(PAPEL.map(x => '.' + x[0]).join(','))) {
  136. if (fora(el) || !vis(el) || !el.textContent.trim()) continue;
  137. const par = PAPEL.find(x => el.classList.contains(x[0])); const cs = getComputedStyle(el);
  138. // a moldura não conta na contagem de papéis (rubrica de design; o mesmo filtro do conta_papeis.py)
  139. papeis.push({papel: par[1], classe: par[0], moldura: !!el.closest('.moldura,.pagina,.arroba'), tamanho: parseFloat(cs.fontSize), entrelinha: parseFloat(cs.lineHeight) || null,
  140. peso: cs.fontWeight === 'bold' ? 700 : parseInt(cs.fontWeight) || 400, texto: el.textContent.replace(/\s+/g, ' ').trim().slice(0, 40)});
  141. }
  142. // negrito: cada .corpo sem li dentro e cada li
  143. const pesoDe = el => { const w = getComputedStyle(el).fontWeight; return w === 'bold' ? 700 : parseInt(w) || 400; };
  144. const unidades = [];
  145. const add = el => {
  146. if (fora(el) || !vis(el)) return;
  147. let txt = '', negrito = false;
  148. const w = document.createTreeWalker(el, NodeFilter.SHOW_TEXT); let m;
  149. while ((m = w.nextNode())) { txt += m.textContent + ' '; if (m.textContent.trim() && pesoDe(m.parentElement) >= 700) negrito = true; }
  150. const palavras = (txt.match(/[0-9A-Za-zÀ-ÿ][^\s]*/g) || []).length;
  151. if (palavras) unidades.push({palavras, negrito});
  152. };
  153. if (tipo) {
  154. for (const el of sl.querySelectorAll('.corpo')) if (!el.querySelector('li')) add(el);
  155. for (const el of sl.querySelectorAll('li')) if (!el.querySelector('li')) add(el);
  156. }
  157. // imagens: img e url() de fundo
  158. const imagens = new Set();
  159. for (const e of [sl, ...sl.querySelectorAll('*')]) {
  160. if (e.tagName === 'IMG' && (e.currentSrc || e.src)) imagens.add(e.currentSrc || e.src);
  161. const bg = getComputedStyle(e).backgroundImage;
  162. for (const u of bg.matchAll(/url\("?([^")]+)"?\)/g)) imagens.add(u[1]);
  163. }
  164. // o texto da tela para o travado: fora a moldura, o adesivo, as marcas e a palavra riscada da correção
  165. let texto = '';
  166. const tw = document.createTreeWalker(sl, NodeFilter.SHOW_TEXT); let n;
  167. while ((n = tw.nextNode())) {
  168. const pe = n.parentElement; if (!n.textContent.trim() || pe.closest('style,script,title,desc')) continue;
  169. if (pe.closest('.moldura,.pagina,.arroba,.pager,.sim,[data-adesivo-sim],svg.marcas')) continue;
  170. if (pe.closest('.corr') && !pe.closest('.sobre')) continue;
  171. const cs = getComputedStyle(pe); if (cs.visibility === 'hidden' || cs.display === 'none') continue;
  172. texto += ' ' + n.textContent;
  173. }
  174. return {tipo, papeis, unidades, imagens: [...imagens], texto};
  175. }"""
  176. def palavras(s):
  177. s = unescape(s or "").lower().replace("’", "'").replace("‑", "-")
  178. return re.findall(r"[0-9a-zà-öø-ÿ]+(?:['-][0-9a-zà-öø-ÿ]+)*", s)
  179. def caminho_de(url):
  180. """O arquivo local de uma URL file:// (None para o resto)."""
  181. u = urlparse(url)
  182. if u.scheme != "file":
  183. return None
  184. p = unquote(u.path)
  185. if re.match(r"^/[A-Za-z]:", p):
  186. p = p[1:]
  187. return Path(p)
  188. @functools.lru_cache(maxsize=None)
  189. def sha(p):
  190. return hashlib.sha256(Path(p).read_bytes()).hexdigest()
  191. def pecas_publicadas(raiz=ROOT):
  192. """As pastas dos carrosséis publicados (**Publicado:** na legenda.md), com o HTML de cada um. Só o carrossel: a
  193. regra é a da I1 ("nenhum desenho repetido da semana anterior sem motivo dito"), e o Story que antecipa ou
  194. compartilha um post repete a imagem dele de propósito."""
  195. out = []
  196. for leg in sorted((raiz / "marketing/social-media/carousels").rglob("legenda.md")):
  197. md = leg.read_text(encoding="utf-8").replace("\r\n", "\n")
  198. if re.search(r"^\*\*Publicado:\*\*[ \t]*\S", md, re.M) and (leg.parent / "slides.html").is_file():
  199. out.append((leg.parent, leg.parent / "slides.html"))
  200. return out
  201. @functools.lru_cache(maxsize=None)
  202. def indice_publicadas(raiz=ROOT):
  203. """{sha256: [nome da peça]} das imagens que moram na pasta de uma peça publicada e que o HTML dela usa."""
  204. idx = {}
  205. for pasta, html in pecas_publicadas(raiz):
  206. h = re.sub(r"<script\b.*?</script>", " ", html.read_text(encoding="utf-8"), flags=re.S)
  207. refs = re.findall(r"""\bsrc\s*=\s*["']([^"']+)["']""", h) + re.findall(r"""url\(\s*["']?([^"')]+)["']?\s*\)""", h)
  208. for r in refs:
  209. if r.startswith(("#", "data:", "http")) or not re.search(r"\.(png|jpe?g|webp|gif|svg)$", r, re.I):
  210. continue
  211. f = (html.parent / unescape(r)).resolve()
  212. if f.is_file() and f.is_relative_to(pasta.resolve()):
  213. idx.setdefault(sha(f), []).append(pasta.name)
  214. return idx
  215. def imagens_ja_publicadas(pasta, imagens, raiz=ROOT):
  216. """[(arquivo, [peças])] das imagens desta tela que já saíram noutra peça publicada."""
  217. out, idx, aqui = [], indice_publicadas(raiz), pasta.resolve().name
  218. for u in imagens:
  219. f = caminho_de(u)
  220. if f is None or not f.is_file():
  221. continue
  222. outras = sorted({p for p in idx.get(sha(f), []) if p != aqui})
  223. if outras:
  224. out.append((f.name, outras))
  225. return out
  226. def _limpa(linhas):
  227. s = " ".join(linhas)
  228. return re.sub(r"\*\((?:[^()]|\([^()]*\))*\)\*", " ", s).replace("==", " ").replace("**", " ").replace("·", " ")
  229. def stories_travados(pasta):
  230. """{story: texto} da seção "## Os Stories" do roteiro.md (as linhas "> " de cada "N. **...**", sem as notas de
  231. produção entre *( )*): o texto dos Stories, que não têm texto.md."""
  232. p = pasta / "roteiro.md"
  233. if not p.is_file():
  234. return {}
  235. texto = p.read_text(encoding="utf-8").replace("\r\n", "\n")
  236. m = re.search(r"^## Os Stories\s*$(.*?)(?=^## |\Z)", texto, re.M | re.S)
  237. if not m:
  238. return {}
  239. return {int(s.group(1)): _limpa([l[2:] for l in s.group(2).splitlines() if l.startswith("> ")])
  240. for s in re.finditer(r"^(\d+)\. \*\*[^\n]*\n(.*?)(?=^\d+\. \*\*|\Z)", m.group(1), re.M | re.S)}
  241. def telas_travadas(pasta):
  242. """{tela: texto} do texto.md travado (os blocos "> " de cada "**Tela N, ...**" da seção "## As telas"); sem
  243. texto.md, o dos Stories pelo roteiro.md (stories_travados)."""
  244. p = pasta / "texto.md"
  245. if not p.is_file():
  246. return stories_travados(pasta)
  247. texto = p.read_text(encoding="utf-8").replace("\r\n", "\n")
  248. m = re.search(r"^## As telas\s*$(.*?)(?=^## |\Z)", texto, re.M | re.S)
  249. corpo = m.group(1) if m else texto
  250. telas = {}
  251. for t in re.finditer(r"^\*\*Tela (\d+),[^\n]*\n(.*?)(?=^\*\*Tela |^## |\Z)", corpo, re.M | re.S):
  252. linhas = [l[2:] for l in t.group(2).splitlines() if l.startswith("> ")]
  253. s = " ".join(linhas)
  254. s = re.sub(r"\*\((?:[^()]|\([^()]*\))*\)\*", " ", s).replace("==", " ").replace("**", " ").replace("·", " ")
  255. telas[int(t.group(1))] = s
  256. return telas
  257. def diferenca_do_travado(travado, visivel):
  258. """(entram, saem): as palavras da tela que o texto travado não tem, e as do travado que a tela não mostra. Conta a
  259. palavra, não as vezes: o ano que o título diz e o rótulo de um desenho repete não é palavra nova."""
  260. a, b = set(palavras(visivel)), set(palavras(travado))
  261. return sorted(a - b), sorted(b - a)
  262. def papel_fora(papeis, tipo, tela, tabela):
  263. """Os AVISOs papel_fora_da_tabela de uma tela da série, contra a tabela do papeis.json dela (carregar_papeis)."""
  264. out, tamanhos = [], {}
  265. chamada = tabela["chamada"]
  266. for p in papeis:
  267. if p["papel"] == "nota" and abs(p["tamanho"] - chamada[0]) <= TOL_PAPEL:
  268. p = dict(p, papel="chamada") # a chamada é a nota no corpo dela (46/72), como "Segue o perfil" nas peças
  269. alvo = tabela[p["papel"]]
  270. t, e = (alvo[0], alvo[1]) if tipo == "a" else (alvo[2], alvo[3])
  271. tamanhos.setdefault(p["papel"], set()).add(round(p["tamanho"]))
  272. dif = []
  273. if abs(p["tamanho"] - t) > TOL_PAPEL:
  274. dif.append(f"corpo {p['tamanho']:g} px (a tabela: {t})")
  275. if p["entrelinha"] and abs(p["entrelinha"] - e) > TOL_PAPEL:
  276. dif.append(f"entrelinha {p['entrelinha']:g} (a tabela: {e})")
  277. if p["peso"] != alvo[4]:
  278. dif.append(f"peso {p['peso']} (a tabela: {alvo[4]})")
  279. if dif:
  280. out.append({"nivel": "AVISO", "conferencia": "papel_fora_da_tabela", "tela": tela, "texto": p["texto"],
  281. "detalhe": f"{p['papel']} no papel {tipo.upper()}: " + ", ".join(dif)
  282. + "; se é desvio, ele vai declarado no refinamentos.md"})
  283. for papel, ts in sorted(tamanhos.items()):
  284. if len(ts) > 1:
  285. out.append({"nivel": "AVISO", "conferencia": "papel_fora_da_tabela", "tela": tela,
  286. "detalhe": f"{papel} em {len(ts)} tamanhos na mesma tela ({', '.join(map(str, sorted(ts)))} px): "
  287. "um tamanho por papel em cada tela"})
  288. return out
  289. # ---- dois testes [código] da rubrica de design (D3 e D4), os dois AVISO provisório ----
  290. # a cor fora dos tokens e os itens por grupo
  291. ITENS_TETO = 4 # D4: "até quatro itens por grupo, salvo o que o design-system.md libera (a lista
  292. # de pendências e a linha do tempo)"
  293. LISTAS_LIBERADAS = ".pendentes,.linha-tempo" # as listas que o design system da série deixa passar de quatro itens
  294. CORES_MAX_DETALHE = 5
  295. # "Papéis tipográficos de conteúdo por tela: até 4; rótulo, fonte e moldura fora" (rubrica de design, "Medidas").
  296. # Com "até 3, rótulo incluído", a maior parte das telas de uma série passava do teto (título, corpo, destaque e nota
  297. # são o padrão do design system); o conta_papeis.py mede a distribuição numa série.
  298. PAPEIS_TETO = 4
  299. PAPEIS_FORA_DA_CONTA = ("fonte",) # o rótulo (.rot, .leg) nem entra na CLASSE_PAPEL; a moldura sai pelo filtro
  300. def papeis_por_tela(papeis, tela):
  301. """O AVISO papeis_por_tela de uma tela da série, sobre os papéis do MEDIR_FORMA (provisório; não barra o --upload)."""
  302. conta = sorted({p["papel"] for p in papeis if not p.get("moldura") and p["papel"] not in PAPEIS_FORA_DA_CONTA})
  303. if len(conta) <= PAPEIS_TETO:
  304. return []
  305. return [{"nivel": "AVISO", "conferencia": "papeis_por_tela", "tela": tela, "texto": ", ".join(conta),
  306. "detalhe": f"{len(conta)} papéis tipográficos de conteúdo na tela, acima de {PAPEIS_TETO} (rubrica de design, "
  307. "\"Medidas\"; o rótulo, a fonte e a moldura ficam fora); provisório, a calibrar com o uso"}]
  308. MEDIR_LOTE5 = r"""(idx) => {
  309. const sl = document.querySelectorAll('.slide')[idx];
  310. const fora = e => !!e.closest('.sim,[data-adesivo-sim],img,picture,video,canvas,defs,mask,clipPath,pattern,filter,marker,symbol');
  311. const vis = e => { const r = e.getBoundingClientRect(); const cs = getComputedStyle(e);
  312. return r.width > 0.5 && r.height > 0.5 && cs.visibility !== 'hidden' && cs.display !== 'none'; };
  313. // os tokens: toda propriedade --* das folhas da página que é uma cor (o caderno.css e o <style> da peça)
  314. const probe = document.createElement('span'); probe.style.display = 'none'; sl.appendChild(probe);
  315. const norm = v => { probe.style.color = ''; probe.style.color = v; return probe.style.color ? getComputedStyle(probe).color : null; };
  316. const tokens = new Set(['rgba(0, 0, 0, 0)']);
  317. const varre = regras => { for (const r of regras) {
  318. if (r.cssRules) varre(r.cssRules);
  319. if (r.style) for (const p of r.style) if (p.startsWith('--')) { const c = norm(r.style.getPropertyValue(p).trim()); if (c) tokens.add(c); } } };
  320. for (const s of document.styleSheets) { try { varre(s.cssRules); } catch (e) {} }
  321. // a folha local (file://) não deixa ler as regras no Chromium: os tokens vêm então do estilo computado, que traz as
  322. // propriedades --* herdadas pela tela (as do :root e as do papel da tela, .tipo-a e .tipo-b)
  323. // (as da tela e as dos descendentes: um token definido num seletor de dentro da tela também vale)
  324. for (const e of [document.documentElement, document.body, sl, ...sl.querySelectorAll('*')]) { const cs = getComputedStyle(e);
  325. for (const p of cs) if (p.startsWith('--')) { const c = norm(cs.getPropertyValue(p).trim()); if (c) tokens.add(c); } }
  326. // o elemento com opacidade acumulada zero não aparece: a cor dele não conta
  327. const apagado = e => { for (let x = e; x && x !== document.documentElement; x = x.parentElement) if (parseFloat(getComputedStyle(x).opacity) === 0) return true; return false; };
  328. const cores = {};
  329. const anota = (cor, e, onde) => {
  330. if (!cor || !cor.startsWith('rgb') || tokens.has(cor)) return;
  331. const k = cor; if (!cores[k]) cores[k] = {cor, n: 0, exemplo: ''};
  332. cores[k].n++;
  333. if (!cores[k].exemplo) cores[k].exemplo = onde + ' em ' + e.tagName.toLowerCase() + (e.getAttribute('class') ? '.' + e.getAttribute('class').trim().split(/\s+/).join('.') : '')
  334. + ((e.textContent || '').trim() ? ' ("' + e.textContent.replace(/\s+/g, ' ').trim().slice(0, 30) + '")' : '');
  335. };
  336. const FORMAS = new Set(['path','rect','circle','ellipse','line','polyline','polygon','text','tspan']);
  337. for (const e of [sl, ...sl.querySelectorAll('*')]) {
  338. if (fora(e) || e.closest('.foto')) continue; // a foto colada com a fita é imagem, não cor do sistema
  339. const cs = getComputedStyle(e);
  340. // a linha reta do svg tem caixa de altura (ou largura) zero: basta um dos lados
  341. const r = e.getBoundingClientRect();
  342. if (cs.visibility === 'hidden' || cs.display === 'none' || (e instanceof SVGElement ? (r.width <= 0.5 && r.height <= 0.5) : !vis(e)) || apagado(e)) continue;
  343. // o degradê e a url() do fundo e o traço ou preenchimento em url(#...) (gradiente e padrão do svg) não se conferem: ficam com a leitura
  344. if (e instanceof SVGElement) {
  345. const tag = e.tagName.toLowerCase(); if (!FORMAS.has(tag)) continue;
  346. if (cs.stroke && cs.stroke !== 'none' && parseFloat(cs.strokeWidth) > 0 && parseFloat(cs.strokeOpacity) > 0) anota(cs.stroke, e, 'traço');
  347. if (tag !== 'line' && cs.fill && cs.fill !== 'none' && parseFloat(cs.fillOpacity) > 0) anota(cs.fill, e, 'preenchimento');
  348. continue;
  349. }
  350. if ([...e.childNodes].some(c => c.nodeType === 3 && c.textContent.trim())) anota(cs.color, e, 'texto');
  351. if (cs.backgroundColor !== 'rgba(0, 0, 0, 0)') anota(cs.backgroundColor, e, 'fundo');
  352. for (const lado of ['Top','Right','Bottom','Left'])
  353. if (parseFloat(cs['border' + lado + 'Width']) > 0 && cs['border' + lado + 'Style'] !== 'none') anota(cs['border' + lado + 'Color'], e, 'borda');
  354. }
  355. probe.remove();
  356. // as listas: os itens de cada ul ou ol fora do svg; a lista de pendências (.pendentes) e a linha do tempo
  357. // (.linha-tempo) o design system libera
  358. const listas = [];
  359. for (const l of sl.querySelectorAll('ul,ol')) {
  360. if (fora(l) || l.closest('svg') || !vis(l) || l.closest('__LIBERADAS__')) continue;
  361. const itens = [...l.children].filter(c => c.tagName === 'LI' && vis(c)).length;
  362. listas.push({itens, texto: l.textContent.replace(/\s+/g, ' ').trim().slice(0, 40)});
  363. }
  364. return {cores: Object.values(cores), tokens: tokens.size, listas};
  365. }""".replace("__LIBERADAS__", LISTAS_LIBERADAS)
  366. def lote5(l5, tela):
  367. """Os AVISOs de cor e de lista numa tela da série: cor_fora_dos_tokens (D3) e itens_por_grupo (D4). Provisórios,
  368. a calibrar com o uso; nenhum barra o --upload."""
  369. out = []
  370. if l5["cores"]:
  371. cs = sorted(l5["cores"], key=lambda c: -c["n"])
  372. out.append({"nivel": "AVISO", "conferencia": "cor_fora_dos_tokens", "tela": tela,
  373. "texto": "; ".join(f"{c['cor']} ({c['exemplo']})" for c in cs[:CORES_MAX_DETALHE]),
  374. "detalhe": f"{len(cs)} cor(es) computada(s) fora das {l5['tokens']} cores dos tokens da página "
  375. "(D3: \"nenhuma cor fora dos tokens?\", rubrica de design); a imagem e a foto ficam de fora; "
  376. "provisório, a calibrar com o uso"})
  377. for li in l5["listas"]:
  378. if li["itens"] > ITENS_TETO:
  379. out.append({"nivel": "AVISO", "conferencia": "itens_por_grupo", "tela": tela, "texto": li["texto"],
  380. "detalhe": f"lista com {li['itens']} itens, acima de {ITENS_TETO} por grupo (D4, rubrica de design; "
  381. "as listas que o design system libera, .pendentes e .linha-tempo, ficam de fora); provisório, a calibrar com o uso"})
  382. return out
  383. def acento_pct(arr, cor):
  384. """% dos pixels a menos de ACENTO_RAIO da cor do acento (r, g, b), com um filtro de croma: o pixel tem de ser
  385. pelo menos tão saturado quanto 60% do acento, para o cinza e o papel perto dele não contarem."""
  386. import numpy as np
  387. a = arr.astype(float)
  388. alvo = np.array(cor, float)
  389. d = np.sqrt(((a - alvo) ** 2).sum(axis=2))
  390. croma = a.max(axis=2) - a.min(axis=2)
  391. piso = 0.6 * (alvo.max() - alvo.min())
  392. return round(float(((d < ACENTO_RAIO) & (croma >= piso)).sum()) / d.size * 100, 3)
  393. def dentro(p, r):
  394. return r[0] <= p[0] <= r[2] and r[1] <= p[1] <= r[3]
  395. def distancia(p, r):
  396. dx = max(r[0] - p[0], 0, p[0] - r[2])
  397. dy = max(r[1] - p[1], 0, p[1] - r[3])
  398. return (dx * dx + dy * dy) ** 0.5
  399. def pontas_das_setas(setas, m, tela):
  400. """Os AVISOs ponta_da_seta de uma tela: as setas lidas antes de o caderno.js trocá-las e postas na tela depois do
  401. prepararSlide (PREPARAR), no mesmo estado em que os alvos se medem.
  402. Toda seta: a ponta cai num alvo (forma do svg que não é traço de seta, foto, imagem, folha que espia), encosta
  403. nele (até SETA_ENCOSTA px da caixa), ou aponta texto (até 40 px de uma linha); senão, termina no vazio. A seta de
  404. anotação (a que sai de uma nota, rótulo ou legenda do kit) que cai dentro de um alvo largo (lado menor de 40 px
  405. ou mais) entra nele de 20 a 30 px pelo design system; menos de 20 avisa. O conector do diagrama (a seta entre dois
  406. desenhos) só precisa encostar: ele aponta de um desenho para o outro, e a regra dos 20 a 30 px é do rótulo."""
  407. out = []
  408. alvos = ([("forma", f["rect"]) for f in m["formas"] if not re.search(r"\b(tinta-[cl]|seta-livre)\b", f.get("fcls", ""))]
  409. + [("figura", r) for r in m["figuras"]] + [("folha", r) for r in m.get("folhas", [])])
  410. linhas = [l for l in m["linhas"] if not l["moldura"] and not l["adesivo"]]
  411. for s in setas:
  412. if s.get("intencional"):
  413. continue
  414. p = s["ponta"]
  415. onde = f"ponta em x {round(p[0])}, y {round(p[1])}"
  416. anotacao = any(l.get("anotacao") and distancia(s["inicio"], l["rect"]) <= SETA_TEXTO_PERTO for l in linhas)
  417. caixas = [(t, r) for t, r in alvos if dentro(p, r) and (r[2] - r[0]) * (r[3] - r[1]) > 4]
  418. if caixas:
  419. tipo, r = min(caixas, key=lambda c: (c[1][2] - c[1][0]) * (c[1][3] - c[1][1]))
  420. prof = min(p[0] - r[0], r[2] - p[0], p[1] - r[1], r[3] - p[1])
  421. if anotacao and min(r[2] - r[0], r[3] - r[1]) >= 2 * SETA_ENTRA_MIN and prof < SETA_ENTRA_MIN:
  422. out.append({"nivel": "AVISO", "conferencia": "ponta_da_seta", "tela": tela,
  423. "detalhe": f"{onde}: a seta da anotação entra {round(prof)} px na caixa do alvo ({tipo}), menos "
  424. "que os 20 a 30 px; a caixa é aproximada, conferir no zoom (juntas.py)"})
  425. continue
  426. if any(distancia(p, r) <= SETA_ENCOSTA for _, r in alvos):
  427. continue
  428. if any(distancia(p, l["rect"]) <= SETA_TEXTO_PERTO for l in linhas):
  429. continue # aponta texto: a sobreposição confere se cruza letra
  430. out.append({"nivel": "AVISO", "conferencia": "ponta_da_seta", "tela": tela,
  431. "detalhe": f"{onde}: termina no vazio, sem entrar nem encostar em desenho, foto ou folha nem apontar "
  432. "texto (toda linha termina em algo)"})
  433. return out
  434. def avisos_da_peca(telas, piso_acento=ACENTO_PISO_PECA):
  435. """Os AVISOs de peça: corpo sem negrito e o piso do acento. `telas`: [{tela, unidades, acento}] das telas da série
  436. (o acento None quando a série não declara a cor); `piso_acento`, o da série (limiares_do_acento)."""
  437. out = []
  438. com_corpo = [t for t in telas if t["unidades"]]
  439. if len(com_corpo) >= NEGRITO_MIN_TELAS:
  440. com_negrito = sum(any(u["negrito"] for u in t["unidades"]) for t in com_corpo)
  441. fr = com_negrito / len(com_corpo)
  442. if fr < NEGRITO_PISO:
  443. sem = [t["tela"] for t in com_corpo if not any(u["negrito"] for u in t["unidades"])]
  444. out.append({"nivel": "AVISO", "conferencia": "corpo_sem_negrito", "tela": "todas",
  445. "detalhe": f"{com_negrito} de {len(com_corpo)} telas com corpo ou lista levam negrito ({round(fr * 100)}%; "
  446. f"o piso é {round(NEGRITO_PISO * 100)}%): o negrito marca as palavras-chave para quem passa os olhos; "
  447. f"sem negrito: telas {sem}"})
  448. medidas = [t["acento"] for t in telas if t.get("acento") is not None]
  449. if medidas:
  450. media = sum(medidas) / len(medidas)
  451. if media < piso_acento:
  452. out.append({"nivel": "AVISO", "conferencia": "acento_area", "tela": "todas",
  453. "detalhe": f"o acento cobre {media:.2f}% da tela na média da peça, abaixo de {piso_acento}%: "
  454. "faltam as marcas no acento?"})
  455. return out
  456. def conferir_legenda_exportacao(legenda):
  457. """Os AVISOs da legenda que só a exportação roda: caractere invisível e a primeira frase depois do corte do feed."""
  458. out = []
  459. inv = sorted({f"U+{ord(c):04X}" for c in INVISIVEIS.findall(legenda)})
  460. if inv:
  461. out.append({"nivel": "AVISO", "conferencia": "caractere_invisivel", "tela": "legenda",
  462. "detalhe": f"{', '.join(inv)} na legenda: caractere que não se vê (colado de outro lugar?)"})
  463. primeira = re.split(r"(?<=[.!?…])\s|\n", legenda.strip(), maxsplit=1)[0]
  464. if len(primeira) > CORTE_LEGENDA - CORTE_MARGEM:
  465. out.append({"nivel": "AVISO", "conferencia": "primeira_frase_legenda", "tela": "legenda",
  466. "detalhe": f"a primeira frase tem {len(primeira)} caracteres; o feed corta a legenda perto de "
  467. f"{CORTE_LEGENDA} (aproximação), e antes do \"mais\" aparece: \"{legenda.strip()[:CORTE_LEGENDA]}\""})
  468. return out

Ratings and comments

Sign in to rate this skill.

Sign in

Free to use. If it’s helped, pass it on.