Open
Source

Preciso estruturar minha metodologia de [sua área, ex: futuros, tendências, foresight, inovação] de forma clara e replicável. Me ajude a definir:

1. Qual é a unidade de análise do meu trabalho? O que eu observo no mundo? Como eu chamo isso?

2. Quais eixos uso para classificar essas observações? Me ajude a pensar em dimensões que façam sentido para o meu contexto. Exemplos: horizonte temporal, geografia, setor, maturidade, impacto.

3. Como agrupo as observações em narrativas maiores? Qual nome dou para esses agrupamentos? Como escolho quais observações entram em cada grupo?

4. Qual é a entrega final para o meu cliente? Um mapa? Uma matriz? Um relatório? Uma apresentação? Como o cliente consome e usa o resultado?

5. Existe algum diagnóstico ou assessment que eu aplico? Um questionário, um framework de avaliação, um modelo de maturidade?

Contexto sobre o meu trabalho:
[Descreva em 2 a 3 parágrafos o que você faz, para quem, e qual tipo de resultado seus clientes esperam. Quanto mais específico, melhor.]

Preciso definir a identidade visual da minha plataforma de [sua área]. Me ajude a criar um sistema de design com:

1. Paleta de cores (primária, secundária, acentos, fundo, texto)
2. Tipografia (uma fonte para títulos, uma para corpo de texto)
3. Tom visual (minimalista, futurista, orgânico, corporativo, editorial)
4. Modo claro, escuro ou ambos?
5. Estilo dos componentes (cards, botões, bordas, espaçamentos)
6. Referências visuais (sites, apps ou plataformas que você admira)

Minha marca:
- Nome: [nome da sua empresa/projeto]
- Cores atuais (se tiver): [suas cores]
- Público: [quem vai usar a plataforma]
- Sensação que quero passar: [ex: sofisticação, acessibilidade, inovação, confiança]

Me entregue as variáveis CSS e as classes Tailwind prontas para usar no projeto.

Crie uma plataforma web de [sua área, ex: futuros, tendências, foresight, inovação] usando Next.js, Tailwind CSS e Supabase.

A plataforma deve ter:

1. Um banco de dados de [suas unidades de análise, ex: sinais, tendências, drivers] com os seguintes campos:
   - Nome
   - Descrição
   - Fonte original (URL)
   - Imagem
   - Data de publicação
   - [Seus eixos de classificação, ex: horizonte temporal (presente/emergente), origem geográfica (local/global), tipo (direto/transversal)]
   - [Seu sistema de scoring, ex: score de relevância de 0 a 10]

2. Uma página de listagem com filtros por [seus eixos] e cards visuais com imagem, nome e classificação.

3. Um sistema de agrupamento chamado [seu nome, ex: cenários, clusters, arenas] que junta [suas unidades] em narrativas maiores, cada uma com:
   - Um [unidade] âncora
   - [N] [unidades] de suporte
   - Uma narrativa explicativa

4. Uma visualização tipo [seu tipo, ex: constelação, matriz, radar, mapa] que mostra os agrupamentos de forma interativa.

5. [Se aplicável] Um diagnóstico/assessment chamado [seu nome] que [descreva o que faz].

6. Design dark mode, minimalista, com tipografia serifada para textos e sans-serif bold para títulos.

7. Uma página explicando a metodologia chamada [nome da sua metodologia].

A metodologia funciona assim:
[Descreva sua metodologia em 3 a 5 parágrafos. Seja específico. Explique os conceitos, os eixos, como as unidades se relacionam, como os agrupamentos são formados e qual é a entrega final para o cliente.]

Crie uma plataforma web de [sua área, ex: futuros, tendências, foresight, inovação] usando Next.js, Tailwind CSS e Supabase.

Use a seguinte estética, inspirada na plataforma Três Ondas da Aerolito:
- Fundo preto (#000000)
- Texto principal: rgba(255,255,255,0.85)
- Texto secundário: rgba(255,255,255,0.35)
- Bordas: rgba(255,255,255,0.08)
- Cor de destaque: #18A4FF (azul) e #18E4FF (ciano)
- Tipografia de títulos: Manrope, weight 800, letter-spacing -0.06em
- Tipografia de corpo: Times New Roman (serif), itálico
- Botões: borda fina, rounded-[2px], texto em 10px weight 800
- Cards: borda fina, rounded-[4px], sem sombra
- Partículas coloridas flutuando no fundo (efeito sutil)
- Layout minimalista com muito espaço em branco (preto)
- Páginas com grid de duas colunas: sidebar sticky à esquerda + conteúdo à direita

A plataforma deve ter:

1. Um banco de dados de [suas unidades de análise, ex: sinais, tendências, drivers] com os seguintes campos:
   - Nome
   - Descrição
   - Fonte original (URL)
   - Imagem
   - Data de publicação
   - [Seus eixos de classificação]
   - [Seu sistema de scoring]

2. Uma página de listagem com filtros e cards visuais.

3. Um sistema de agrupamento chamado [seu nome] que junta [suas unidades] em narrativas maiores.

4. Uma visualização interativa dos agrupamentos.

5. [Se aplicável] Um diagnóstico/assessment chamado [seu nome] que [descreva o que faz].

6. Uma página explicando sua metodologia.

A metodologia funciona assim:
[Descreva sua metodologia em 3 a 5 parágrafos.]

Você é um consultor sênior de futuros da Aerolito. Analise o briefing e selecione entre 12 e 24 sinais que tenham CONEXÃO REAL com a demanda do cliente.

REGRA FUNDAMENTAL: Cada sinal selecionado deve ter uma razão clara de estar ali. Pergunte-se: "se eu apresentar este sinal ao cliente, ele vai entender por que foi escolhido?" Se a resposta for não, NÃO inclua.

CONEXÃO DIRETA: sinal do mesmo mercado do cliente.
CONEXÃO TRANSVERSAL: sinal de outro mercado, mas que contém uma lógica, modelo ou tecnologia que pode ser aplicada ao contexto do cliente. Exemplo: um seguro paramétrico para agricultura pode inspirar seguros paramétricos para pessoa física.

NÃO INCLUA sinais que não tenham conexão clara. É melhor selecionar 12 sinais excelentes do que 24 mediocres.

CLIENTE: [nome da empresa]
MERCADO: [mercado do cliente]
TAGS DE INTERESSE: [tags separadas por vírgula]

Priorize sinais que se conectem diretamente com essas tags. As tags representam os temas que o cliente quer explorar.

CRITÉRIOS DE SELEÇÃO:

1. DIRETO vs TRANSVERSAL (baseado no mercado do cliente):
   - ~[X] sinais diretos (do mercado do cliente) + ~[Y] transversais
   - IGNORE flags pré-classificadas no banco. Avalie você mesmo.

2. PRESENTE vs EMERGENTE: ~[X] presente + ~[Y] emergente

3. BRASIL vs MUNDO: ~[X] brasil + ~[Y] mundo

4. FONTE: Sempre priorize sinais cuja fonte seja a sua própria curadoria. Preencha primeiro com sinais próprios e só complete com outras fontes se necessário.

5. INOVAÇÃO: Priorize os sinais mais inovadores. Nunca selecione sinais genéricos ou óbvios.

6. Tente respeitar as 3 proporções simultaneamente. Quando houver conflito, aproxime o máximo possível.

SINAIS DISPONÍVEIS:
[sua lista de sinais com id, nome, mercado, eixos, fonte]

TERRITÓRIOS DISPONÍVEIS:
[sua lista de territórios com id, nome, descrição]

Selecione entre 12 e 24 sinais e até 5 territórios. Responda APENAS com JSON, sem markdown:
{"signals":["id1","id2","..."],"territories":["id1","..."]}

// scripts/import-signals.ts
// Lê um CSV e insere cada linha na tabela signals do Supabase.
// CSV esperado: name,source_url,category (uma linha por sinal)

import { createClient } from '@supabase/supabase-js'
import * as fs from 'fs'

const supabase = createClient(
  process.env.NEXT_PUBLIC_SUPABASE_URL!,
  process.env.SUPABASE_SERVICE_ROLE_KEY!
)

async function main() {
  const csv = fs.readFileSync('signals.csv', 'utf-8')
  const lines = csv.split('\n').slice(1).filter(Boolean)

  for (const line of lines) {
    const [name, source_url, category] = line.split(',').map(s => s.trim())
    const { error } = await supabase
      .from('signals')
      .insert({ name, source_url, category, summary: '' })
    console.log(error ? `✗ ${name}: ${error.message}` : `✓ ${name}`)
  }
}

main()

// scripts/enrich-signals.ts
// Lê sinais com summary vazio e pede para o Claude escrever uma versão editorial.
// O prompt define o estilo: análise + citações + exemplos concretos.

import Anthropic from '@anthropic-ai/sdk'
import { createClient } from '@supabase/supabase-js'

const anthropic = new Anthropic({ apiKey: process.env.ANTHROPIC_API_KEY! })
const supabase = createClient(
  process.env.NEXT_PUBLIC_SUPABASE_URL!,
  process.env.SUPABASE_SERVICE_ROLE_KEY!
)

const SYSTEM_PROMPT = `Você é um futurista editorial. Expande sinais de futuro curtos em textos editoriais profundos.

ESTILO:
- Português brasileiro fluente
- Começa com uma definição clara do conceito
- Cita autores, pesquisadores, livros e frameworks (com ano)
- Dá exemplos concretos de empresas que aplicam o conceito
- Conecta o sinal a implicações para lideranças corporativas
- Tom: analítico mas acessível
- Extensão: 800-1500 palavras

REGRAS:
- NÃO invente dados numéricos específicos
- PODE citar autores, livros e frameworks reais e conhecidos
- O texto deve ser autossuficiente
- Escreva APENAS o texto do summary, sem título nem marcadores`

async function enrich(name: string, category: string) {
  const r = await anthropic.messages.create({
    model: 'claude-haiku-4-5-20251001',
    max_tokens: 8192,
    system: SYSTEM_PROMPT,
    messages: [{
      role: 'user',
      content: `Expanda este sinal:
Categoria: ${category}
Nome: ${name}

Escreva o summary em português (800-1500 palavras):`,
    }],
  })
  return r.content[0].type === 'text' ? r.content[0].text : ''
}

async function main() {
  const { data } = await supabase
    .from('signals')
    .select('id, name, category, summary')
    .limit(50)

  for (const s of data || []) {
    if ((s.summary || '').length >= 500) continue
    const text = await enrich(s.name, s.category)
    await supabase.from('signals').update({ summary: text }).eq('id', s.id)
    console.log(`✓ ${s.name}`)
    await new Promise(r => setTimeout(r, 3000))
  }
}

main()

// scripts/fetch-images.ts
// Para cada sinal sem imagem, busca uma foto no Unsplash usando o nome do sinal.

import { createClient } from '@supabase/supabase-js'

const supabase = createClient(
  process.env.NEXT_PUBLIC_SUPABASE_URL!,
  process.env.SUPABASE_SERVICE_ROLE_KEY!
)
const UNSPLASH_KEY = process.env.UNSPLASH_ACCESS_KEY!

async function searchUnsplash(query: string): Promise<string | null> {
  const r = await fetch(
    `https://api.unsplash.com/search/photos?query=${encodeURIComponent(query)}&per_page=1`,
    { headers: { Authorization: `Client-ID ${UNSPLASH_KEY}` } }
  )
  const data = await r.json()
  return data.results?.[0]?.urls?.regular ?? null
}

async function main() {
  const { data } = await supabase
    .from('signals')
    .select('id, name')
    .is('image_url', null)
    .limit(50)

  for (const s of data || []) {
    const url = await searchUnsplash(s.name)
    if (url) {
      await supabase.from('signals').update({ image_url: url }).eq('id', s.id)
      console.log(`✓ ${s.name}`)
    } else {
      console.log(`✗ ${s.name} (sem resultado)`)
    }
    await new Promise(r => setTimeout(r, 1000))
  }
}

main()

// scripts/reclassify-transversal.ts
// Re-aplica a regra Direto/Transversal em batch contra todos os sinais.
// Um sinal só é Transversal se genuinamente não pertence a nenhum mercado.

import Anthropic from '@anthropic-ai/sdk'
import { createClient } from '@supabase/supabase-js'

const anthropic = new Anthropic({ apiKey: process.env.ANTHROPIC_API_KEY! })
const supabase = createClient(
  process.env.NEXT_PUBLIC_SUPABASE_URL!,
  process.env.SUPABASE_SERVICE_ROLE_KEY!
)

// Ajuste para os mercados da sua metodologia
const MARKETS = [
  'Construção', 'Saúde', 'Financeiro', 'Esportes',
  'Educação', 'Alimentação', 'Mobilidade', 'Transversal'
]

const SYSTEM_PROMPT = `Você é um classificador de sinais de inovação.

Sua tarefa é classificar cada sinal em UMA das seguintes categorias de mercado:

${MARKETS.map(m => `- ${m}`).join('\n')}

REGRA FUNDAMENTAL: um sinal só é Transversal se genuinamente não pertence a nenhum mercado específico — se é uma tecnologia, comportamento ou tendência que atravessa múltiplos setores sem pertencer a nenhum deles. Na dúvida, escolha o mercado mais provável.

Exemplos:
- Coliving, construção modular → Construção
- Wearable de saúde, telemedicina → Saúde
- Fintech, pagamentos, criptomoeda → Financeiro
- IA generativa sem aplicação setorial específica → Transversal

Responda APENAS com um JSON array. Cada elemento: {"id": "...", "category": "...", "reason": "..."}.
A reason deve ter no máximo 15 palavras.`

async function main() {
  const { data: signals } = await supabase
    .from('signals')
    .select('id, name, summary')
    .limit(50)

  const list = (signals || []).map(s =>
    `- ID: ${s.id} | Nome: ${s.name} | Resumo: ${(s.summary || '').slice(0, 200)}`
  ).join('\n')

  const r = await anthropic.messages.create({
    model: 'claude-haiku-4-5-20251001',
    max_tokens: 4096,
    temperature: 0.1,
    system: SYSTEM_PROMPT,
    messages: [{ role: 'user', content: `Classifique:

${list}` }],
  })

  const text = r.content[0].type === 'text' ? r.content[0].text : ''
  const match = text.match(/\[[\s\S]*\]/)
  if (!match) return console.log('JSON não encontrado na resposta')
  const classifications = JSON.parse(match[0])

  for (const c of classifications) {
    await supabase.from('signals').update({ category: c.category }).eq('id', c.id)
    console.log(`✓ ${c.id} → ${c.category}: ${c.reason}`)
  }
}

main()

// scripts/translate-signals.ts
// Traduz sinais para português brasileiro e corrige acentos ausentes.

import Anthropic from '@anthropic-ai/sdk'
import { createClient } from '@supabase/supabase-js'

const anthropic = new Anthropic({ apiKey: process.env.ANTHROPIC_API_KEY! })
const supabase = createClient(
  process.env.NEXT_PUBLIC_SUPABASE_URL!,
  process.env.SUPABASE_SERVICE_ROLE_KEY!
)

async function translate(name: string, summary: string) {
  const r = await anthropic.messages.create({
    model: 'claude-haiku-4-5-20251001',
    max_tokens: 8192,
    messages: [{
      role: 'user',
      content: `Traduza o título e o resumo para português brasileiro.

REGRAS:
- Traduza TODO o conteúdo para português brasileiro fluente
- Nomes próprios de empresas, pessoas e tecnologias mantêm o nome original (ex: OpenAI, Tesla, CRISPR)
- Corrija acentos ausentes
- Mantenha o mesmo tom e significado
- Retorne APENAS um JSON com "name" e "summary"

Título: ${name}
Resumo: ${summary}

JSON:`,
    }],
  })
  const text = r.content[0].type === 'text' ? r.content[0].text : ''
  const m = text.match(/\{[\s\S]*\}/)
  return m ? JSON.parse(m[0]) : null
}

async function main() {
  const { data } = await supabase
    .from('signals')
    .select('id, name, summary')
    .limit(50)

  for (const s of data || []) {
    const result = await translate(s.name, s.summary || '')
    if (result) {
      await supabase
        .from('signals')
        .update({ name: result.name, summary: result.summary })
        .eq('id', s.id)
      console.log(`✓ ${s.name}`)
    }
    await new Promise(r => setTimeout(r, 2000))
  }
}

main()