Conversor Livro-para-Skill

Transforme conhecimento escrito em skills acionáveis para agentes, extraindo estrutura — não produzindo resumos.

Filosofia

Livros contêm expertise cristalizada: frameworks, princípios e técnicas que levaram anos para serem desenvolvidos. Esta skill extrai esse conhecimento para um formato que o GitHub Copilot CLI, Amp, Claude Code ou outro agente compatível possa aproveitar repetidamente.

Extraia estrutura, não resumos. Uma skill não é uma resenha de livro. É um kit de ferramentas de:

Frameworks nomeados (modelos mentais com aplicação clara)
Princípios acionáveis (regras que guiam decisões)
Técnicas (métodos passo a passo)
Antipadrões (o que evitar e por quê)
Calibração de voz (como o autor pensa e se comunica)

Preserve a precisão do autor. Frameworks geralmente têm nomes específicos por um motivo. "Os 5 Porquês" não é intercambiável com "perguntar por que várias vezes." Capture a formulação exata.

Distribua a profundidade adequadamente. Livros simples → skills simples. Livros complexos com 10+ frameworks → skills com arquivos de referência e capítulos sob demanda.

Modos de Operação

Quatro caminhos disponíveis. Escolha com base no que o usuário pede:

1. Conversão Completa (Padrão)

Gatilho: O usuário fornece um ou mais caminhos de documento/diretório/glob sem instruções especiais Ação: Executar todas as etapas abaixo (Etapas 0–9) Saída: Skill completa com SKILL.md, chapters/, glossário, padrões, cheatsheet

2. Somente Análise

Gatilho: O usuário diz "analisar", "apenas extrair" ou "quero revisar antes de gerar" Ação: Executar Etapas 0–3 e produzir um relatório de extração estruturado (frameworks, princípios, técnicas encontradas). Parar — NÃO gerar arquivos de skill. Saída: Relatório de análise para revisão do usuário

3. Gerar a partir de Análise Anterior

Gatilho: O usuário tem notas de análise existentes ou executou "somente análise" anteriormente Ação: Pular Etapas 0–3, usar a análise fornecida como entrada, executar Etapas 4–9 Saída: Arquivos de skill a partir da análise fornecida

4. Atualizar / Incorporar (Skill Existente)

Gatilho: O usuário fornece um ou mais novos caminhos de origem e indica que deseja atualizar uma skill existente (apontando para a pasta da skill existente, fornecendo um slug de skill que já existe em SKILLS_HOME, ou solicitando explicitamente uma atualização). Ação: Executar Etapa 0 (verificação de escopo), Etapa 1 (validar entradas), Etapa 1.5 (identificar tipo de livro) e Etapa 2 (extrair novos arquivos). Em seguida, pular para a Etapa 5 (identificar/detectar caminho da skill existente) e executar o Fluxo de Trabalho de Atualização/Incorporação para mesclar o novo conteúdo nos arquivos de skill existentes. Saída: Skill existente atualizada com novos/resumos de capítulo revisados e índices/glossários mesclados.

Localizações das Skills

Este conversor pode ser executado a partir de vários sistemas de skills. Ao procurar pelo script auxiliar deste conversor ou ao escrever a skill de livro gerada, prefira estas localizações nesta ordem:

Skills pessoais do GitHub Copilot CLI: ~/.copilot/skills/
Skills pessoais cross-agent (Copilot + Amp): ~/.agents/skills/
Skills pessoais do Claude Code: ~/.claude/skills/
Skills do Copilot local ao projeto: .github/skills/
Skills do Claude Code local ao projeto: .claude/skills/
Skills do Amp / Copilot local ao projeto: .agents/skills/
Skills globais do Amp: ~/.config/agents/skills/
Skills globais legadas do Amp: ~/.config/amp/skills/

Para skills de livro geradas, escolha um destino que o agente host do usuário possa realmente descobrir (veja a Etapa 5). Quando mais de uma raiz válida existir, pergunte ao usuário uma vez e lembre a resposta para a sessão — não use um padrão silencioso.

Etapa 0 — Verificação de escopo

Se nenhum argumento for fornecido, pare e responda:

"book-to-skill requer um caminho de documento compatível, pasta ou padrão glob. Uso: book-to-skill <caminho-para-pasta-de-documentos-ou-glob>... [slug-nome-da-skill]"

Durante todo o fluxo de trabalho:

Identifique os caminhos de entrada e o slug de skill opcional.
Se o último argumento não for um arquivo, pasta ou glob que exista ou corresponda a qualquer arquivo, e parecer um slug de skill (ex.: hífens minúsculos, alfanumérico), trate-o como SKILL_NAME.
Trate todos os outros argumentos como a lista de INPUT_PATHS.
Se algum caminho de entrada for um diretório de skill existente (contém SKILL.md e uma subpasta chapters/), ou se SKILL_NAME corresponder a um slug de skill existente em SKILLS_HOME, sinalize esta execução como uma operação de Atualização/Incorporação (Modo 4).

Etapa 1 — Validar entrada

Verifique se há pelo menos um arquivo, diretório ou padrão glob compatível entre os INPUT_PATHS. Para diretórios e globs, expanda-os para encontrar arquivos compatíveis correspondentes (.pdf, .epub, .docx, .txt, .md, .markdown, .rst, .adoc, .html, .htm, .rtf, .mobi, .azw, .azw3).

Se nenhum arquivo compatível for encontrado, pare com uma mensagem de erro clara.

Etapa 1.5 — Identificar tipo de conteúdo

Antes de extrair, pergunte ao usuário:

"Que tipo de conteúdo estas fontes têm? Isso me ajuda a escolher o melhor método de extração.

Técnico — tem blocos de código, tabelas, fórmulas, diagramas (ex.: livros de programação, artigos acadêmicos, guias de arquitetura)

Texto denso — principalmente prosa, poucas ou nenhuma tabela/código (ex.: gestão, produtividade, não-ficção narrativa)

Não sei — Usarei o método rápido e avisarei se a qualidade parecer limitada"

Armazene a resposta como BOOK_TYPE:

Opção 1 → BOOK_TYPE=technical
Opção 2 → BOOK_TYPE=text
Opção 3 → BOOK_TYPE=text

Se BOOK_TYPE=technical, informe o usuário antes de prosseguir:

"📐 Modo técnico selecionado — usando Docling para extração consciente da estrutura (tabelas, blocos de código, fórmulas preservados como markdown). Isso leva ~1,5s por página, então espere alguns minutos para fontes mais longas. Começando agora…"

Se BOOK_TYPE=text, informe:

"📄 Modo texto selecionado — usando o extrator mais rápido adequado para cada tipo de arquivo. Texto simples/Markdown/HTML geralmente ficam prontos em segundos; PDFs usam pdftotext quando disponível."

Etapa 2 — Extrair texto dos documentos fonte

Execute o script de extração, passando os caminhos de entrada:

SCRIPT_PATH=""
for candidate in \
  "$HOME/.copilot/skills/book-to-skill/scripts/extract.py" \
  "$HOME/.agents/skills/book-to-skill/scripts/extract.py" \
  "$HOME/.claude/skills/book-to-skill/scripts/extract.py" \
  ".github/skills/book-to-skill/scripts/extract.py" \
  ".claude/skills/book-to-skill/scripts/extract.py" \
  ".agents/skills/book-to-skill/scripts/extract.py" \
  "$HOME/.config/agents/skills/book-to-skill/scripts/extract.py" \
  "$HOME/.config/amp/skills/book-to-skill/scripts/extract.py"
do
  if [ -f "$candidate" ]; then
    SCRIPT_PATH="$candidate"
    break
  fi
done

if [ -z "$SCRIPT_PATH" ]; then
  echo "Não foi possível encontrar scripts/extract.py para book-to-skill" >&2
  exit 1
fi

PYTHON_BIN="${PYTHON_BIN:-python3}"
if ! command -v "$PYTHON_BIN" >/dev/null 2>&1; then
  PYTHON_BIN="python"
fi

"$PYTHON_BIN" "$SCRIPT_PATH" $INPUT_PATHS --mode <BOOK_TYPE> --install-missing ask

Antes da extração, o script verifica pacotes Python opcionais necessários para o formato detectado. Se um extrator melhor estiver faltando, ele pergunta ao usuário com o fallback disponível. Sessões não interativas usam o fallback por padrão, a menos que o modo de instalação seja explicitamente yes.

Dica — pré-configurar o ambiente: execute "$PYTHON_BIN" "$SCRIPT_PATH" --check para imprimir um relatório por formato de quais extratores estão instalados e o comando exato para instalar o que estiver faltando, sem processar nenhum arquivo. Útil quando um usuário relata um problema de configuração ou qualidade.

Isso cria:

<tempdir>/book_skill_work/full_text.txt — texto extraído combinado de todas as fontes com limites visualmente demarcados.
<tempdir>/book_skill_work/metadata.json — tamanho total combinado, palavras, páginas, contagens de tokens e uma lista detalhada de sources processadas individualmente.

Leia <tempdir>/book_skill_work/metadata.json para inspecionar os resultados.

Etapa 2.5 — Estimativa de custo pré-voo

Leia <tempdir>/book_skill_work/metadata.json e apresente ao usuário uma estimativa antes de fazer qualquer geração:

📖 Fontes detectadas: <total_sources> fonte(s)
<lista cada nome de arquivo e formato da lista de metadados de fontes>
📄 Páginas/Seções combinadas: ~<N> | Palavras: ~<N> | Total de tokens: ~<N>K

💰 Custo estimado de tokens (Conversão Completa / Atualização):
   Entrada (leitura + prompts): ~<N>K tokens
   Saída (arquivos de skill gerados/atualizados):  ~<N>K tokens
   Total:                                    ~<N>K tokens

   Custo: multiplique as contagens de tokens acima pelas taxas atuais por
   1M-tokens de entrada/saída do seu modelo (preços e nomes de modelos mudam
   com frequência — não os codifique; cite a taxa de hoje e rotule como estimativa).

   ⏱  Tempo estimado: ~<N> minutos

📁 Arquivos a serem gerados/atualizados:
   SKILL.md + arquivos de capítulo + glossário + padrões + cheatsheet

➡  Prosseguir com Conversão Completa / Atualização? (ou digite "somente análise" para visualizar primeiro)

Como estimar:

Tokens de entrada ≈ estimated_tokens dos metadados × 1.3 (sobrecarga de prompts por passagem de capítulo)
Tokens de saída ≈ capítulos × orçamento por capítulo + 4.000 (SKILL.md) + 4.500 (glossário + padrões + cheatsheet)
- Orçamento por capítulo mediano por BOOK_TYPE (DEPTH é decidido depois na Etapa 4 e pode aumentá-lo): text ≈ 1.000, technical ≈ 1.800. Se o usuário já indicou apenas referência vs estudo aprofundado, use a linha correspondente da matriz da Etapa 7.
Custo: reporte as contagens de tokens e multiplique pelas taxas atuais de entrada/saída por 1M-tokens do usuário. NÃO codifique valores em dólar — nomes e preços de modelos mudam; se você mostrar um, rotule-o como estimativa e date-o.

Aguarde a confirmação do usuário antes de prosseguir. Se ele disser "somente análise", mude para o Modo 2.

Etapa 2.6 — Acesso estilo REPL para livros grandes (> 50k tokens)

Inspirado no paradigma do Modelo de Linguagem Recursivo (RLM): trate full_text.txt como um corpus consultável, não como uma única leitura. Carregar o arquivo inteiro no contexto gasta orçamento que você precisará depois para geração.

Para livros acima de ~50k tokens, prefira sondagens programáticas em vez de Read(full_text.txt) sem limites:

# Verificação de tamanho antes de qualquer Read
wc -w "$FULL_TEXT_PATH"

# Encontre deslocamentos de capítulo sem carregar o arquivo inteiro
grep -n -E "^\s*(Chapter|CHAPTER)\s+[0-9]+" "$FULL_TEXT_PATH" | head -40

# Puxe apenas o capítulo que você precisa (linhas início..fim inclusivo)
sed -n '<inicio>,<fim>p' "$FULL_TEXT_PATH"

# Verifique se um framework é realmente mencionado antes de reivindicá-lo no SKILL.md
grep -c -i "westrum\|dora" "$FULL_TEXT_PATH"

# Leitura direcionada com deslocamento/limite evita despejar o arquivo completo
# Read(file_path=full_text.txt, offset=<linha>, limit=<linhas>)

Use esta abordagem para a Etapa 3 (análise de estrutura), Etapa 7 (resumos por capítulo) e Etapa 8 (extração de glossário/padrões). Em livros com menos de 50k tokens, um único Read é suficiente.

Por que isso importa: um livro de 200 páginas tem ~75k tokens. Rele-lo uma vez por capítulo (28 passagens) custa ~2M tokens de entrada; usar grep + sed para puxar apenas as fatias relevantes mantém o custo de geração proporcional à saída, não à fonte.

Etapa 3 — Analisar estrutura do livro

Leia os primeiros 8.000 caracteres do full_text.txt extraído para identificar:

Título do livro e autor(es)
Estrutura de capítulos (procure por "Capítulo N", "PARTE I", cabeçalhos numerados, sumário)
Temas centrais e domínio do assunto
Número aproximado de capítulos

Em seguida, leia a seção de Sumário, se presente, para mapear todos os capítulos.

Se o modo for "Somente Análise": produza o relatório de extração agora e pare. Estrutura:

## Relatório de Extração — <Título>

### Frameworks Centrais do Autor
- **<Nome do Framework>**: <o que é e quando aplicar>

### Princípios Chave
- <Princípio>: <regra acionável>

### Técnicas e Métodos
- <Técnica>: <passo a passo ou como fazer>

### Antipadrões
- <O que evitar>: <por quê>

### Nome Sugerido para a Skill
`{sobrenome-do-autor}-{conceito-central}` — ex.: `cialdini-influence`

### Capítulos Detectados
| # | Título | Frameworks Principais |

Etapa 4 — Perguntar propósito (Somente Conversão Completa)

Antes de gerar, pergunte ao usuário:

"Para que esta skill deve ajudá-lo? (Escolha um ou mais)

Aplicar os frameworks do autor enquanto trabalha

Pensar com os modelos mentais do autor

Consultar capítulos e conceitos específicos

Todos os anteriores"

Use a resposta para ponderar o que é destacado na seção Core do SKILL.md.

Derive DEPTH da resposta (sem prompt extra):

A resposta é apenas a opção 3 (consulta) → DEPTH=reference — capítulos enxutos, de consulta rápida.
A resposta inclui a opção 1, 2 ou 4 → DEPTH=study — capítulos mais profundos com mais detalhes trabalhados, exemplos e raciocínio.

DEPTH e BOOK_TYPE juntos definem o orçamento de tokens por capítulo na Etapa 7. Não faça uma pergunta separada "estudo vs consulta" — ela é inferida aqui. (Nos Modos 2/3, onde a Etapa 4 é pulada, o padrão DEPTH=study é usado.)

Etapa 5 — Determinar nome da skill

Se SKILL_NAME foi fornecido, use-o como o slug da skill. Caso contrário, proponha duas opções e deixe o usuário escolher:

Por autor-conceito: {sobrenome-do-autor}-{conceito-central} (ex.: cialdini-influence, meadows-systems)
Por título: hífens minúsculos a partir do título do livro (ex.: designing-data-intensive-apps)

Use o formato autor-conceito como padrão se o livro tiver uma identidade metodológica forte.

Escolha a raiz de skill de destino (SKILLS_HOME). Sonda o sistema de arquivos do usuário em busca de homes de skill existentes e escolha pelo agente host que o usuário está executando:

Agente host	Pessoal	Local do projeto	Global
Claude Code	`~/.claude/skills/`	`.claude/skills/`	—
GitHub Copilot CLI	`~/.copilot/skills/`	`.github/skills/`	—
Amp	`~/.agents/skills/`	`.agents/skills/`	`~/.config/agents/skills/`
Copilot+Cross-agent	`~/.agents/skills/`	`.agents/skills/`	—

Se a raiz escolhida não existir (ex.: ~/.agents/skills/ não foi criada ainda), o escopo da skill determina o tratamento:

Skill pública/para todos os projetos → crie a raiz: mkdir -p "$SKILLS_HOME$SKILL_NAME"
Skill privada/para um projeto → use uma raiz diferente? Ou informe o usuário primeiro.
Incerteza → mostre um resumo dos diretórios de skill detectados e pergunte onde colocar.

Etapa 6 — Criar diretórios de saída

SKILL_DIR="$SKILLS_HOME/$SKILL_NAME"
mkdir -p "$SKILL_DIR"
mkdir -p "$SKILL_DIR/chapters"
mkdir -p "$SKILL_DIR/glossary"
mkdir -p "$SKILL_DIR/patterns"

Etapa 7 — Gerar capítulos

Para cada capítulo detectado na Etapa 3, gere um arquivo de skill de capítulo no alvo $SKILL_DIR/chapters/.

Orçamento por capítulo baseado em DEPTH:

BOOK_TYPE	DEPTH=reference	DEPTH=study
`text`	500 tokens/capítulo	1.000 tokens/capítulo
`technical`	1.000 tokens/capítulo	2.000 tokens/capítulo

Formato do arquivo de capítulo:

# <Número do Capítulo>: <Título do Capítulo>

## Resumo
<Resumo de 2-3 frases do capítulo>

## Frameworks e Conceitos
- **<Framework Nomeado>**: <Definição concisa e quando aplicá-lo>

## Pontos-chave
- <Ponto chave acionável 1>
- <Ponto chave acionável 2>

## Exemplos padrão (se relevantes)
- <Contexto>: <Ação tomada>

## Conexões
- Liga a: <Capítulo X>, <Capítulo Y>

Opção de extração de capítulo na Etapa 2.6: Se o livro tiver menos de 50k tokens, leia full_text.txt uma vez e processe todos os capítulos. Se for maior, use sed ou Read com deslocamento para puxar capítulos sob demanda.

Extraia os capítulos em paralelo/batches para minimizar o número de viagens de ida e volta, mas em lotes pequenos o suficiente para que cada solicitação permaneça focada (máximo 5 capítulos por prompt).

Etapa 8 — Extrair glossário e padrões

Digitalize o texto extraído em busca de:

Termos de glossário: termos definidos, jargões e siglas. Cada entrada deve ter: termo, definição concisa, capítulo de origem.
Padrões: padrões de design recorrentes, heurísticas, regras práticas e princípios. Cada padrão deve ter: nome, resumo, guia de aplicação, contexto/pré-condições, capítulo de origem.
Antipadrões: práticas nocivas, mitos, erros comuns. Cada antipadrão deve ter: nome, problema, por que é prejudicial (de acordo com o autor), alternativa, capítulo de origem.

Salve:

Glossário como $SKILL_DIR/glossary/glossary.md
Padrões como $SKILL_DIR/patterns/patterns.md
Antipadrões como $SKILL_DIR/patterns/antipatterns.md

(Nota de formato: manter padrões e antipadrões em arquivos separados, não um arquivo combinado "patterns-and-antipatterns".)

Gere o arquivo de cheatsheet como $SKILL_DIR/patterns/cheatsheet.md. O cheatsheet deve ser uma visão geral de referência rápida (< 2.000 tokens) que captura os frameworks, princípios e técnicas mais importantes como uma folha de dicas que o usuário pode consultar rapidamente.

Etapa 9 — Gerar SKILL.md

Combine os artefatos das etapas anteriores em $SKILL_DIR/SKILL.md.

Estrutura:

# <Nome da Skill>

## Visão Geral
<Uma descrição de 3-4 frases de quem é o autor, o domínio do livro e como esta skill ajuda>

## Frameworks Centrais
<Frameworks mais importantes, quando usar cada um, e sua interação>

## Princípios
<Princípios-chave com dicas de aplicação>

## Técnicas
<Técnicas práticas, procedimentos, fluxos de trabalho>

## Temas e Conexões Transversais
<Conexões entre capítulos, temas recorrentes, como as ideias se constroem>

## Prevenção de Alucinações
- **Não invente termos ou frameworks que não estão no livro.** Se um conceito parece se encaixar, mas você não tem certeza se está nos capítulos extraídos, verifique com grep.
- **Atribua corretamente.** Se uma ideia é semelhante a algo que você conhece de outro lugar, mas o autor a chama de outra forma, use o termo do autor.
- **Cuidado com exemplos.** Use apenas exemplos e casos extraídos do texto.
- **Quando não souber, diga.** "Não encontrado nos capítulos extraídos" é melhor do que inventar.
- **Cuidado com citações e estatísticas.** Se você não puder verificar o número ou citação exatos a partir do texto extraído, não os invente. Atribua de forma vaga ou omita.

## Padrões Relacionados (deste livro)
<Lista dos 5-7 padrões mais importantes com links>

## Cheatsheet
<Referência rápida dos frameworks, princípios, técnicas e antipadrões mais importantes>

## Técnicas e Métodos
<Técnicas práticas, procedimentos, fluxos de trabalho>

## Colofão
- Palavras-chave do autor: <5-10 palavras-chave que capturam a voz e o léxico do autor>
- Domínio: <domínio do assunto>
- Nível: <iniciante|intermediário|avançado>
- Formato da skill: <resumo|guia de estudo>
- Suporta: Claude Code, GitHub Copilot CLI, Amp, e outros agentes compatíveis

Nota: As seções "Frameworks Centrais", "Princípios" e "Técnicas" são a parte mais importante do SKILL.md. Elas devem ser substanciais (não apenas listas de marcadores). Se o espaço permitir, inclua fundamentos e raciocínio por trás de cada framework, não apenas uma definição de uma linha.

Fluxo de Trabalho de Atualização / Incorporação

Propósito: Mesclar novo conteúdo de um ou mais novos documentos em uma skill de livro existente sem regenerar tudo do zero.

Etapa 5 (variante de atualização) — Identificar caminho da skill existente

Encontre o diretório da skill existente:

Se o usuário forneceu um caminho: use-o diretamente.
Se o usuário forneceu um slug de skill: procure $HOME/.{agent}/skills/$SLUG/, depois {projeto}/.github/skills/$SLUG/, depois {projeto}/.claude/skills/$SLUG/. Use o primeiro que existir.
Caso contrário, o slug será gerado na Etapa 5; em seguida, use o caminho correspondente se já existir.

Etapas 6-7 (variante de atualização) — Extrair e gerar novo conteúdo

Siga a Etapa 2 com os novos documentos, depois as Etapas 3-4 (usando o BOOK_TYPE da skill existente, a menos que o usuário especifique o contrário). Extraia novos resumos de capítulo e entradas de framework.

Etapa 8 (variante de atualização) — Mesclar glossário, padrões, cheatsheet

Para cada tipo de arquivo:

Leia o arquivo existente se ele existir.
Extraia novos termos/padrões das novas fontes.
Mescle: adicione termos/padrões que são novos; atualize entradas existentes se a nova fonte fornecer informações mais completas; resolva duplicatas retendo a versão mais detalhada.
Anote cada entrada mesclada com (fonte: [título do documento original]) para rastreabilidade.

Etapa 9 (variante de atualização) — Revisar SKILL.md

Releia o SKILL.md existente.
Atualize a Visão Geral para refletir o escopo expandido.
Adicione/revise Frameworks Centrais, Princípios e Técnicas com base no novo conteúdo.
Se os novos documentos introduzirem um subdomínio ou variação significativamente diferentes, considere adicionar uma seção "Conteúdo Relacionado" ou "Skills Relacionadas" em vez de misturar tudo.
Preserve a voz e a estrutura da skill existente; não a reescreva a menos que o usuário solicite explicitamente.

Ferramentas e Dependências

Esta skill de conversor usa:

Python 3 — para executar scripts/extract.py
extract.py — um script de extração de texto multi-formato incluído com a skill
Pacotes Python opcionais: Docling (para extração de PDF técnica), pdftotext (para extração de PDF rápida), python-docx (para DOCX), etc. O script extract.py relatará e solicitará pacotes faltantes.

A skill depende de ferramentas de agente padrão:

Bash ou shell — para executar comandos Python e comandos do sistema (grep, sed, wc)
Read — para ler arquivos extraídos e metadados
Write — para escrever arquivos de skill de saída
Glob — para encontrar e expandir arquivos de entrada
Grep — para pesquisa direcionada

Exemplos de uso

# Converter um único PDF (Conversão Completa)
book-to-skill ~/Downloads/thinking-fast-and-slow.pdf kahneman-thinking

# Converter um diretório de documentos (por exemplo, vários artigos)
book-to-skill ./artigos/

# Extrair estrutura sem gerar skill (Modo Somente Análise)
book-to-skill ~/Downloads/rfc-constraint.pdf --analisar

# Atualizar uma skill existente com novos capítulos
book-to-skill ~/Downloads/novo-capitulo.pdf --atualizar minha-skill

# Usar na linha de comando do Claude Code
claude "book-to-skill ~/Downloads/designing-data-intensive-apps.pdf"

Troubleshooting

"extract.py não encontrado"

Certifique-se de que a raiz da skill foi instalada em um dos caminhos listados na Etapa 2. Execute find ~/.claude/skills -name "extract.py" para verificar.

A extração parece incompleta ou de baixa qualidade

Execute "$PYTHON_BIN" "$SCRIPT_PATH" --check para ver quais extratores estão instalados. Para PDFs técnicos, instale o Docling: pip install docling.

O agente não consegue descobrir a skill gerada

Certifique-se de que $SKILL_DIR contém um SKILL.md e uma subpasta chapters/. Verifique se o agente host está configurado para procurar na raiz de skill escolhida.

A geração está muito cara para livros longos

Use a Etapa 2.6 (acesso estilo REPL) para evitar ler o livro inteiro de uma vez. Considere definir DEPTH=reference para orçamentos de tokens mais baixos.

Segurança e Considerações

Nunca carregue texto extraído em fóruns públicos ou serviços de terceiros.
Conteúdo de livros pode ser protegido por direitos autorais. Esta skill extrai estrutura para referência pessoal; não redistribua o texto completo do livro.
A skill depende de ferramentas de shell e Python — agende auditar scripts baixados se você obtiver extract.py de terceiros.
Por padrão, --install-missing ask — o script solicitará instalação de pacotes. Sessões não interativas usarão fallbacks sem instalação.

Perguntar na sua IA favorita

Documentação