Get the FREE Ultimate OpenClaw Setup Guide →

riligar-dev-website-seo

npx machina-cli add skill riligar/agents-kit/riligar-dev-website-seo --openclaw
Files (1)
SKILL.md
5.2 KB

SEO Técnico (RiLiGar Tech Stack)

Arquivos da Skill

Esta skill utiliza os seguintes arquivos de referência:

  • SKILL.md (este arquivo): Guia central de implementação
  • references/implementation.md: Templates de código para React/Vite e Bun/Elysia
  • references/checklist.md: Checklist pré-lançamento
  • references/structured-data.md: Templates de markup JSON-LD

O que esta Skill cobre

  1. Sitemaps → Geração dinâmica via Bun/Elysia ou estática via Vite/public.
  2. Robots.txt → Diretivas para crawlers.
  3. Meta Tags → OpenGraph, Twitter Cards, descrições e títulos.
  4. Dados Estruturados → Schema markup (JSON-LD) para rich snippets.
  5. URLs Canônicas → Prevenção de conteúdo duplicado.
  6. Performance & Vitals → Otimização para os Core Web Vitals.

Part 1: Implementação de Sitemap

Em projetos RiLiGar, o sitemap pode ser estático (em public/sitemap.xml) ou dinâmico via backend Elysia.

Sitemap Estático (Vite public/sitemap.xml)

Para sites institucionais simples:

<?xml version="1.0" encoding="UTF-8"?>
<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">
  <url>
    <loc>https://riligar.com/</loc>
    <lastmod>2025-01-20</lastmod>
    <changefreq>weekly</changefreq>
    <priority>1.0</priority>
  </url>
</urlset>

Sitemap Dinâmico (Elysia /backend)

Se o site tiver conteúdo dinâmico (postagens de blog, produtos), crie um endpoint no Elysia:

// src/routes/seo.js
import { Elysia } from 'elysia'
import { db } from '../database/db'

export const seoRoutes = new Elysia().get('/sitemap.xml', async ({ set }) => {
    const posts = await db.query.posts.findMany()
    const baseUrl = 'https://riligar.com'

    const xml = `<?xml version="1.0" encoding="UTF-8"?>
<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">
    <url>
        <loc>${baseUrl}</loc>
        <priority>1.0</priority>
    </url>
    ${posts
        .map(
            post => `
    <url>
        <loc>${baseUrl}/blog/${post.slug}</loc>
        <lastmod>${post.updatedAt.toISOString().split('T')[0]}</lastmod>
        <priority>0.7</priority>
    </url>`
        )
        .join('')}
</urlset>`

    set.headers['Content-Type'] = 'application/xml'
    return xml
})

Part 2: Implementação de Robots.txt

O robots.txt deve ficar na pasta public/ do frontend ou ser servido pelo backend.

User-agent: *
Allow: /
Disallow: /api/
Disallow: /dashboard/
Disallow: /admin/

# Block AI training bots
User-agent: GPTBot
Disallow: /
User-agent: ChatGPT-User
Disallow: /
User-agent: CCBot
Disallow: /

Sitemap: https://riligar.com/sitemap.xml

Part 3: Metadata e Meta Tags

Em SPAs (Single Page Applications) React/Vite, use metadados estáticos no index.html ou gerencie dinamicamente.

No index.html (Baseline)

<title>RiLiGar — Sua Tagline</title>
<meta
    name="description"
    content="Descrição chamativa de 150-160 caracteres."
/>

<!-- OpenGraph -->
<meta
    property="og:type"
    content="website"
/>
<meta
    property="og:title"
    content="RiLiGar — Sua Tagline"
/>
<meta
    property="og:description"
    content="Descrição para redes sociais."
/>
<meta
    property="og:image"
    content="https://riligar.com/og-image.png"
/>

<!-- Twitter -->
<meta
    name="twitter:card"
    content="summary_large_image"
/>
<meta
    name="twitter:title"
    content="RiLiGar — Sua Tagline"
/>
<meta
    name="twitter:image"
    content="https://riligar.com/og-image.png"
/>

Dinâmico (Server-side Injection no Elysia)

Para melhores resultados de SEO em conteúdo dinâmico, o Elysia pode injetar as tags no HTML enviado:

// Exemplo simples de injeção no Elysia
app.get('/*', async ({ path }) => {
    let html = await Bun.file('dist/index.html').text()

    if (path.startsWith('/blog/')) {
        const post = await getPost(path.split('/')[2])
        html = html.replace('<title>RiLiGar</title>', `<title>${post.title} | RiLiGar</title>`)
        html = html.replace('content="RiLiGar description"', `content="${post.excerpt}"`)
    }

    return new Response(html, { headers: { 'Content-Type': 'text/html' } })
})

Part 4: Variáveis de Ambiente

Sempre configure a URL base nos arquivos de ambiente:

# .env.development
VITE_SITE_URL=http://localhost:5173
SITE_URL=http://localhost:3000

# .env.production
VITE_SITE_URL=https://riligar.com
SITE_URL=https://riligar.com

Checklist de Implementação

  1. robots.txt configurado e bloqueando /admin e /dashboard.
  2. sitemap.xml gerado e acessível.
  3. Meta tags OpenGraph e Twitter presentes em todas as páginas públicas.
  4. Imagem OG de 1200x630px em public/og-image.png.
  5. Canonical URLs apontando para a versão preferencial.
  6. Dados estruturados (JSON-LD) para Organização no Home.
  7. Headers de performance (preload de fontes) no index.html.

Para detalhes específicos, consulte os arquivos na pasta references/.

Source

git clone https://github.com/riligar/agents-kit/blob/prod/.agent/skills/riligar-dev-website-seo/SKILL.mdView on GitHub

Overview

Esta skill entrega a infraestrutura de SEO técnico para a stack RiLiGar (React, Vite, Bun, Elysia), cobrindo sitemaps, robots.txt, meta tags, OpenGraph, dados estruturados (JSON-LD) e URLs canônicas. O objetivo é tornar o site mais rastreável, melhorar o ranking e reduzir conteúdo duplicado, acompanhando Core Web Vitals.

How This Skill Works

A implementação pode ser estática, com sitemap.xml em public, ou dinâmica via backend Elysia gerando /sitemap.xml. Robots.txt pode ser servido a partir de public/ ou pelo backend. Metadados e OpenGraph/Twitter Tags podem ser estáticos no index.html ou injetados dinamicamente pelo servidor Elysia usando templates. Dados estruturados JSON-LD seguem templates em references/structured-data.md e são injetados conforme o conteúdo da página. URLs canônicas são gerenciadas para evitar duplicação de conteúdo.

When to Use It

  • Lançamento de site RiLiGar requerendo SEO técnico completo com sitemaps, robots.txt e meta tags.
  • Conteúdo dinâmico (blog/produtos) que precisa de sitemaps atualizados automaticamente.
  • Bloqueio de bots indesejados (IA e crawlers) via robots.txt para áreas sensíveis.
  • Necessidade de OpenGraph/Twitter Cards consistentes para redes sociais.
  • Objetivo de melhorar Core Web Vitals e evitar conteúdo duplicado com canônicos.

Quick Start

  1. Step 1: Decida between sitemap estático (public/sitemap.xml) ou dinâmico via Elysia e configure o endpoint se necessário.
  2. Step 2: Adicione robots.txt em public/ com diretivas claras e inclua a linha Sitemap: https://seu-dominio/sitemap.xml.
  3. Step 3: Implemente metadados (index.html ou injecção pelo Elysia) e conecte JSON-LD aos templates existentes; valide tudo com ferramentas de SEO.

Best Practices

  • Escolha entre sitemap estático (public/sitemap.xml) e dinâmico (Elysia) com base na frequência de atualização de conteúdo.
  • Mantenha robots.txt simples e direto, bloqueando áreas sensíveis e incluindo o sitemap.
  • Use URLs canônicas absolutas e consistentes em todas as páginas para evitar duplicação.
  • Injete metadados e dados estruturados dinamicamente para conteúdo variável quando possível.
  • Valide tudo com ferramentas de SEO (validação de sitemap, robots.txt, Rich Results Test) e atualize templates conforme necessário.

Example Use Cases

  • Sitemap estático em public/sitemap.xml para um site institucional RiLiGar.
  • Sitemap dinâmico via endpoint /sitemap.xml no Elysia para posts do blog.
  • Robots.txt em public/ bloqueando /api/, /admin/ e incluindo a referência ao sitemap.
  • Meta tags estáticas no index.html com OpenGraph e Twitter Cards configurados.
  • Templates JSON-LD em references/structured-data.md usados por páginas dinâmicas.

Frequently Asked Questions

Add this skill to your agents
Sponsor this space

Reach thousands of developers