Início › Ajuda

Ajuda & recursos do LightNote

Documentação completa de tudo o que o LightNote faz — a mesma ajuda que abre no app com a tecla F1. Use o índice abaixo para navegar por cada recurso.

✍️ Editor de código 🧠 Notas & segundo cérebro 🤖 Vibe coding (IA + MCP)

Ajuda do LightNote

Editor leve de código e notas para Windows. A barra lateral lista as seções e acompanha o que você está lendo; os botões Início e Voltar no topo da janela retornam ao começo, e o campo Buscar procura no texto da ajuda (Enter avança; F3 / Shift+F3 navegam). Pressione F1 a qualquer momento para abrir esta ajuda já na seção da tela atual.

Índice

Edição

Ferramentas

Automação (IA / scripts)

Referência

Visão geral

O LightNote abre uma pasta como Espaço de trabalho e mostra a árvore de arquivos à esquerda, as abas de edição à direita e a barra de status embaixo. A barrinha no topo da barra lateral alterna entre as seções Explorador (árvore), Buscar, Versionamento (Git), Histórico do arquivo e Pendências (TODO/FIXME e tarefas das notas).

Além de código e notas, ele abre e edita vários formatos no lugar certo: tabelas (Parquet/CSV/JSON via DuckDB e Excel .xlsx), PDF, imagens (incluindo GIF animado), .zip como pasta, cadernos de Blocos (.lnb), quadros de Tarefas (.lnt), tabelas personalizadas (.lnd), conexões de banco de dados (.lnc) e de SSH (.lns). Tem terminal integrado, busca global (ripgrep), versionamento Git simplificado, integração com CLIs de IA, um servidor MCP e uma linha de comando (lnote) para automação.

Novo por aqui? O material de apresentação (o Espaço de trabalho de boas-vindas) continua acessível a qualquer momento em Ajuda → Reabrir tour de boas-vindas.

Espaço de trabalho e janelas

A pasta-raiz aberta é o seu Espaço de trabalho. Apenas abri-la não cria nada; ao fechar, o LightNote grava só um pequeno arquivo de sessão (abas abertas e posição). O espaço só vira um "projeto" — com configuração própria persistida — quando você ativa o Versionamento (Git) ou o MCP em Ferramentas → Configuração do Espaço de Trabalho.

As Configurações Gerais valem para o aplicativo inteiro; a Configuração do Espaço de Trabalho vale só para a pasta aberta. Configuração e estado ficam num banco central, não espalhados pela pasta.

O LightNote roda como instância única: abrir uma segunda pasta reaproveita o processo (multi-janela, menos memória). Há ícone na bandeja e um launcher com campo de busca que lista os Espaços de Trabalho (fixe os favoritos no topo pelo menu de contexto) — veja Notas diárias e bandeja. Cada aba pode receber uma etiqueta de cor pelo menu de contexto da barra de abas. Para notas repetitivas, crie uma pasta Modelos (ou Templates) com arquivos .md e use Arquivo → Nova nota a partir de modelo…

Criar arquivo escolhendo o tipo. O menu Novo (☰ Arquivo, botão Novo da barra de atividades ou Criar novo no menu de contexto de uma pasta) traz Nova nota (.md), Novo arquivo de texto (.txt) e o submenu Novo arquivo de código com as linguagens mais usadas. Em todos, o arquivo nasce no disco na hora com um nome padrão e a árvore já abre a edição do nome — só o nome é pré-selecionado, então digitar um título não apaga a extensão. Para aceitar o nome sugerido, basta clicar no editor e começar a escrever. Para uma extensão fora do submenu, crie um arquivo e renomeie (F2): trocar a extensão troca a visão — renomear .txt para .md reabre a mesma aba como nota, com preview e sumário, e o contrário devolve o editor de código. As extensões próprias do LightNote (.lnc, .lne, .lnq, .lnh, .lns e os bundles) são exceção: nelas a extensão declara o formato do conteúdo, então renomear pede confirmação e é recusado enquanto a aba estiver aberta.

Onde o arquivo novo é criado. O Novo cria sempre na pasta marcada no Explorador, e há sempre exatamente uma marcada. No topo da árvore fica a linha da pasta-raiz, com o nome do espaço de trabalho: ela é um item como os outros — clique nela para devolver o destino à raiz. Selecionar uma pasta move a marca para ela; selecionar um arquivo marca a pasta que o contém. No modo Lista, que não mostra pastas, a marca fica na linha-raiz e ela exibe o destino efetivo. O menu de contexto da linha-raiz traz Criar novo e Criar pasta.

Para abrir um arquivo solto sem transformá-lo num espaço de trabalho, use Abrir arquivo avulso… (menu da bandeja): a janela avulsa mostra a árvore de arquivos, mas sem Git, MCP nem override de tema. Se ativado em Configurações → Geral → Recursos, o LightNote se integra ao menu do Explorer do Windows (por usuário, sem exigir administrador): além da lista "Abrir com", o menu de contexto ganha "Abrir com o LightNote" em qualquer arquivo e "Abrir como espaço de trabalho do LightNote" em pastas (no Windows 11, dentro de Mostrar mais opções). Arquivos abrem nessa janela avulsa; pastas abrem como espaço de trabalho.

Selecionando vários arquivos de uma vez no Explorer do Windows — inclusive de pastas diferentes — todos abrem na mesma janela avulsa, aba ao lado de aba (em vez de espalhar uma janela por arquivo). As abas dessa janela são lembradas: ao fechá-la e abri-la de novo, os mesmos arquivos voltam. Como o foco aqui são as abas, a árvore de arquivos começa recolhida — use Ctrl+B (ou o botão no topo da barra de atividades) para exibi-la.

Voltando a uma sessão. A janela de arquivos avulsos se chama Arquivos avulsos em todo lugar — inclusive na barra de título, no lugar onde as outras janelas mostram o nome do espaço de trabalho, para você distingui-las no Alt+Tab. No menu da bandeja, em Abrir, o item ganha o sufixo (N abas) quando há abas guardadas — clicar traz todas de volta. Ela também é a primeira linha do launcher, ao lado dos espaços de trabalho. E, ao reabrir o LightNote, ele volta com tudo o que estava aberto quando você saiu: cada janela na sua pasta, mais a janela avulsa. Se preferir abrir só a última pasta usada, troque em Configurações → Geral → Interface → Ao iniciar, abrir. Uma janela que você fechou antes de sair fica de fora — fechar é o jeito de dizer "terminei com este espaço".

Favoritos: a barra lateral tem uma seção Favoritos com o que você fixou (menu de contexto da árvore ou da aba → Adicionar aos favoritos) e os arquivos abertos recentemente. Os fixados são por pasta e ficam guardados como caminhos relativos, então sobrevivem a mover o espaço de trabalho.

Abrir uma aba em janela própria: no menu de contexto da aba, Abrir em nova janela reabre aquele arquivo numa janela avulsa (útil para comparar uma nota ao lado do código). Tipos que dependem do espaço de trabalho (.lnc, .lne, .lns e os bundles) não podem ser destacados.

Seleção múltipla. A árvore aceita Ctrl+clique (avulso) e Shift+clique (intervalo) nos três modos de visão. Com vários itens selecionados, o menu de contexto passa a operar sobre a seleção inteira: Recortar e Copiar (interoperando com o Explorer do Windows), Apagar (uma única confirmação para todos), Duplicar, Copiar hash, Comprimir para .zip (um arquivo só, cada item com o próprio nome no topo), Aplicar cor, Favoritos, Git (add/restore) e Copiar caminhos (uma linha por item). As ações que só fazem sentido para um item — renomear inline, Propriedades, Abrir como, Converter — ficam desabilitadas, com o motivo no tooltip. Clicar com o botão direito dentro da seleção a preserva; clicar fora dela seleciona só o item clicado. Selecionar uma pasta e algo dentro dela não faz a operação duas vezes: o item de dentro é descartado.

Espiar sem abrir. O clique simples num arquivo já abre uma aba de prévia (reaproveitada, em itálico na barra de abas). Percorrendo a árvore com as setas, a tecla Espaço faz o mesmo e devolve o foco à árvore, para você seguir descendo a lista.

Ferramentas de arquivo. O menu de contexto do Explorador traz o submenu Ferramentas de arquivo: Renomear em lote (filtro por extensão/curinga/regex + pipeline de regras com pré-visualização e detecção de colisão), Dividir arquivo (por linhas, tamanho ou separador regex), Juntar arquivos (mantendo só o 1º cabeçalho de CSV, opcional), Duplicar, Copiar hash (MD5/SHA-256) e Comprimir para .zip / Extrair aqui. Com vários itens selecionados, Renomear em lote e Juntar arquivos recebem exatamente os itens escolhidos (em vez de varrer a pasta) — e o Juntar respeita a ordem da seleção.

Navegação da janela avulsa. No alto da árvore há voltar (Alt+←), avançar (Alt+→) e subir, mais uma trilha de pastas clicável — cada segmento leva àquele nível. Os botões laterais do mouse também voltam e avançam. Para digitar um caminho, clique no vazio da faixa ou use Ctrl+L; Esc desiste e volta à trilha. Trocar de aba também move a pasta exibida: como a janela avulsa reúne abas de pastas diferentes, clicar numa aba navega até a pasta dela.

Menus. O botão ☰ (topo da barra de atividades) reúne os menus Arquivo, Editar, Exibir, Janela, Ferramentas, IA e Ajuda. As ações de IA têm menu próprio (também no botão da varinha, na barra de atividades). Em Ferramentas, os grupos ficam em submenus: Executar (F5/F6/F8, lint, enviar ao terminal, macros), Capturar (nota de hoje, captura rápida, tarefa rápida, gravar áudio, notas adesivas) e Espaço de Trabalho (configuração, snapshot, exportar cópia, mover pasta) — este último também no menu da engrenagem. O menu Novo é o mesmo nos três lugares em que aparece: ☰ Arquivo, botão Novo da barra de atividades e Criar novo do menu de contexto de uma pasta.

Editor de código

Arquivos de texto/código abrem no editor (Scintilla) com realce de sintaxe. Há comentar/descomentar (Ctrl+/), mover e duplicar linha, marcadores (Ctrl+F2), lista de símbolos/funções, autocompletar por palavras, guias de indentação, quebra de linha, zoom e detecção de alteração do arquivo em disco. Com o versionamento ativo, a margem mostra as linhas adicionadas/alteradas desde a última versão.

Há ainda macros (gravar/reproduzir uma sequência de edições com Ctrl+Shift+R / F4, em Ferramentas → Macros), formatar/beautify (Shift+Alt+F), uma tabela ASCII na barra da aba (para inserir caracteres/molduras) e corretor ortográfico (Hunspell). O pt-BR e o en-US já vêm embutidos; os demais idiomas você baixa sob demanda na tabela de Configurações → Notas e escrita → Ortografia (uma linha por idioma, com botão Baixar/Remover). Para acompanhar um arquivo de log sendo escrito, use o botão Monitorar (tail -f) na barra da própria aba. Arquivos muito grandes (acima de ~1 MB) abrem num editor leve virtualizado, que carrega só os trechos visíveis; é possível forçá-lo em Arquivo → Abrir no editor leve…

Formatar e verificar (linters): Shift+Alt+F formata o documento com o formatador externo da linguagem (black, prettier, clang-format, gofmt, rustfmt…) quando instalado, caindo no formatador interno (JSON/XML) offline; F7 roda o linter da linguagem (ruff, eslint, shellcheck, luacheck…) e marca os problemas com sublinhado no editor e no painel Problemas (pane inferior, navegável). Ambos têm um catálogo com Adicionar em Configurações → Formatação e → Linters, e opções de formatar ao salvar / verificar ao salvar. Rode o arquivo no painel de saída com F6 (captura código de saída e duração, com parar/reiniciar) ou só um trecho com F8.

Mais recursos de edição: multi-cursor por ocorrência (Ctrl+D, todas com Alt+F3), duplicar linha (Ctrl+Shift+D), juntar linhas (Ctrl+Shift+J), expandir/reduzir seleção por escopo (Ctrl+Shift+Espaço / Ctrl+Alt+Espaço), seleção retangular (Alt+arraste), dobrar/expandir tudo, trechos/snippets (Ctrl+J, editáveis em Configurações → Editor), Ir para símbolo no arquivo (# na paleta) e no projeto (Ctrl+T ou ##), histórico de navegação (Alt+←/→), trilha de navegação (breadcrumbs) no topo do editor, réguas de coluna, colorir pares de parênteses, auto-fechar/cercar pares e higiene ao salvar (aparar espaços, quebra final) — tudo em Configurações → Editor.

Histórico local e área de transferência: a cada gravação, o LightNote guarda uma versão do arquivo (Arquivo → Histórico local…, restaurável), independente do Git. Ctrl+Alt+V abre o histórico da área de transferência para colar um item copiado anteriormente. Ctrl+Shift+T reabre a última aba fechada; as abas podem ser fixadas (menu de contexto), o que as protege da liberação por inatividade.

Ir à definição: F12 ou Ctrl+clique sobre um identificador salta para onde ele é definido no projeto; Shift+F12 localiza os usos.

Minimap. Uma miniatura do documento inteiro fica na borda direita do editor: ela mostra a “forma” do código (as cores do realce de sintaxe em escala reduzida) e marca a região visível. Clique ou arraste nela para navegar até qualquer ponto do arquivo. Ligue/desligue em Exibir → Minimap ou em Configurações → Editor. O botão Minimap da barra da própria aba de código (ao lado do ASCII) liga e desliga sem sair do editor. Na borda esquerda da miniatura fica uma faixa de marcas: em azul as linhas com marcador (a mesma bolinha da margem) e em âmbar as ocorrências da busca rápida — assim você vê de relance como elas se espalham pelo arquivo inteiro, mesmo nas partes que estão fora da tela.

Operações de texto. No menu Editar — e no menu de contexto do editor — ficam os submenus Linhas (mover, duplicar, deletar, ordenar, juntar, inverter, numerar) e Limpeza (aparar espaços, remover linhas vazias/duplicadas, tabulações ↔ espaços). Com um trecho selecionado, o menu de contexto também traz Salvar seleção como novo arquivo…: grava o trecho num arquivo ao lado do atual e o abre numa aba (o original não é alterado).

Markdown e wikilinks

Notas .md abrem com editor e preview lado a lado (configurável). A marcação é esmaecida fora do parágrafo do cursor para a página parecer um documento pronto.

Atalhos: Ctrl+B/Ctrl+I aplicam negrito/itálico e Ctrl+E alterna o modo de exibição (edição → dividido → leitura).

Wikilinks: digite [[ para autocompletar com as notas do espaço de trabalho; o link fecha sozinho com ]]. Segure Ctrl e clique num [[nota]] para abrir a nota correspondente. O painel de Links mostra as conexões entre as notas.

Preview enriquecido: blocos de código entre cercas aparecem numa caixa com rótulo da linguagem e link copiar; ~~tachado~~ e ==realce== são renderizados; e callouts do estilo GitHub (> [!NOTE], [!TIP], [!WARNING], [!IMPORTANT], [!CAUTION]) viram caixas coloridas. Tags #hashtag são realçadas e, com Ctrl+clique, abrem a busca por aquela tag; o bloco de frontmatter YAML no topo (---) é realçado. Na barra da aba há um botão para exportar a nota em PDF/HTML, uma coluna de leitura centrada alternável e os modos editor/ambos/preview. O modo Zen (F11) e a rolagem máquina de escrever ajudam a escrever sem distrações.

Novidades do preview: além de ~~tachado~~ e ==realce==, funcionam sobrescrito ^x^, subscrito ~x~, emoji por atalho em inglês (:rocket:), autolink de URLs, notas de rodapé [^1], blocos recolhíveis <details>, listas de definição, tarefas - [ ]/- [x] (⬜/✅) e o token [TOC] (sumário clicável no preview); também imagens locais e HTML inline (<kbd>, <mark>…). O painel Sumário (barra da aba) navega pelos cabeçalhos acompanhando o cursor, e o botão Inserir (ou o menu de contexto → Formatar/Inserir) aplica qualquer marcação.

Cabeçalhos fixos (sticky scroll): ao rolar, os cabeçalhos que contêm a linha do topo ficam presos numa faixa no alto do editor; clicar num deles salta para a seção (ligue/desligue em Configurações → Markdown). O menu de contexto de uma pasta na árvore cria/abre a Nota da pasta (index.md com frontmatter), útil como índice.

Nota de pasta e lista de arquivos: dar duplo-clique numa pasta abre a sua index.md, se existir. Dentro de qualquer nota, o token [files] (ou [arquivos]) sozinho numa linha é trocado no preview pela lista dos arquivos da pasta da nota, como links clicáveis — gerada na hora, sem gravar nada no arquivo (igual ao [TOC]).

Operações de texto e de linha. As mesmas operações do editor de código valem na nota — pelo botão Texto da barra da aba, pelo menu de contexto e pelos submenus Linhas e Limpeza do menu Editar: mover a linha (ou as linhas selecionadas) para cima/baixo (Ctrl+Shift+↑/↓), duplicar (Ctrl+Shift+D), deletar (Ctrl+Shift+L), ordenar (A→Z / Z→A), inverter a ordem, juntar linhas, remover linhas duplicadas ou vazias, aparar espaços e caixa (MAIÚSCULAS/minúsculas/inverter). Numerar linhas… abre um diálogo com início, passo, zeros à esquerda e separador — com o padrão (". ") o resultado é uma lista numerada Markdown válida. Com uma seleção, a operação atua só nela (expandida a linhas inteiras); sem seleção, no documento todo — sempre num único passo de desfazer. A barra da aba também traz o botão IA (Perguntar / Editar com IA), o mesmo Ctrl+K / Ctrl+I do código.

Cabeçalhos dobráveis: clique na setinha à esquerda de um cabeçalho (ou use Ctrl+Shift+[ / Ctrl+Shift+]) para recolher e expandir a seção; em Exibir há Recolher/Expandir todos os cabeçalhos. A dobra é só visual — nunca é escrita no arquivo — e o LightNote a lembra entre sessões. Saltar do Sumário ou da busca para dentro de uma seção recolhida a expande.

Propriedades da nota: a mini-barra Propriedades mostra o frontmatter YAML como campos tipados (texto, número, data, caixa de seleção), com a caixa Tipo no topo. Definir o tipo e as propriedades é o que permite reunir as notas numa Base.

Grafo de conexões

Ferramentas › Grafo de conexões (Ctrl+Alt+G) mostra todas as notas do espaço de trabalho como um grafo interativo: cada nó é uma nota .md, cada linha um wikilink. Os nós se acomodam sozinhos (física animada) e podem ser arrastados; passar o mouse destaca os vizinhos e esmaece o resto; clique abre a nota. Role o mouse para dar zoom (os nomes aparecem ao aproximar) e arraste o fundo para mover a vista.

Na barra da aba: filtro por nome (esmaece as notas que não casam), toggle de notas órfãs (sem nenhum link — ficam em cinza), sliders de força (repulsão, distância e gravidade), ajustar o grafo à janela e re-varrer as notas. Quanto mais conexões uma nota tem, maior o nó; cada pasta de 1º nível ganha uma cor.

Tabelas (Parquet, CSV, JSON, Excel)

Arquivos .parquet abrem como tabela; .csv, .tsv e .json abrem como texto, e o menu de contexto da árvore oferece Abrir como tabela. A leitura é paginada (sob demanda) via DuckDB, com ordenação (clique no cabeçalho) e filtro empurrados para o engine. O botão Estrutura mostra colunas, tipos, nº de linhas e, no Parquet, row-groups e compressão. A visão é somente leitura.

A barra de SQL livre no topo da tabela aceita uma consulta DuckDB qualquer — a view t representa o arquivo aberto. Pelo menu de contexto de uma pasta na árvore, Abrir pasta como tabela lê todos os arquivos do mesmo formato como uma tabela só; pelo menu da tabela dá para exportar a visão atual (CSV/Parquet/JSON) e pelo menu da árvore, converter um arquivo tabular para outro formato. SQL livre também está no comando query da linha de comando e no MCP.

Planilhas Excel (.xlsx) abrem como tabela somente-leitura, com um seletor de planilha (aba) — leitura leve, sem precisar do Excel instalado.

Copiar como. No menu de contexto de qualquer tabela do LightNote (Parquet/CSV/JSON, Excel, resultado de SQL, Tarefas, Bases) o item Copiar como leva a seleção para a área de transferência já formatada. Tabela formatada (Teams, Outlook…) cola como uma tabela de verdade, com bordas e cabeçalho, nos programas que entendem texto rico — Teams, Outlook, Word, Excel (onde não há texto rico, cai automaticamente para TSV). Os demais colam como texto: tabela Markdown (pronta para uma nota), CSV (com aspas conforme a RFC 4180), TSV (separado por tabulação), HTML (a marcação <table>), JSON, JSONL (um registro por linha), YAML e o submenu Código, que gera um literal pronto para colar num arquivo-fonte: Python (lista de dicionários) ou JavaScript / TypeScript (array de objetos). Em JSON, YAML e código as células que são números saem sem aspas — mas o texto original é preservado, então IDs como 007 continuam texto. Ctrl+C continua copiando em TSV, como antes.

Todas as tabelas se comportam igual: Ctrl+F foca o filtro rápido ("contém em qualquer coluna"), um contador mostra quantas linhas sobraram e há Exportar para CSV — inclusive nas planilhas .xlsx, nas Tarefas e nas Bases. O menu de contexto da grade ainda traz Copiar como.

Gráfico do resultado. A mini-barra lateral da tabela tem um botão Gráfico (barras, linha ou dispersão): a agregação roda no DuckDB (nada de linha crua sobe), e um botão Adicionar à nota do dia grava o gráfico como imagem. O painel Estrutura traz ainda um perfil por coluna — mini-histograma das colunas numéricas e os valores mais comuns das demais.

PDF e imagens

Arquivos .pdf abrem num visualizador nativo (Qt6::Pdf, sem dependências pesadas), renderizado em CPU e sem WebEngine. Imagens abrem na visão de imagem; GIFs animados tocam na visão animada.

A barra da aba traz cinco painéis laterais, um de cada vez: Sumário (o índice gravado no próprio arquivo — quando o PDF não tem, o botão fica desabilitado explicando o porquê), Miniaturas (as páginas de relance, renderizadas conforme você rola), Buscar, Links e Propriedades (título, autor, datas, tamanho da página e do arquivo).

Buscar (Ctrl+F) procura em todo o documento: as ocorrências ficam realçadas nas páginas e listadas com o trecho ao redor, e F3 / Shift+F3 passam de uma para a outra. A varredura é progressiva, então a lista cresce enquanto o documento é percorrido.

O campo de página aceita o número ou o rótulo impresso: num documento cujo prefácio é numerado em romanos, digitar 1 leva à página impressa "1", não à primeira folha. O botão de modo de página alterna entre rolagem contínua e uma página por vez.

Um PDF protegido por senha pede a senha ao abrir (até três tentativas); cancelar apenas não abre a aba. Dentro da mesma execução do LightNote a senha não é pedida de novo — o aplicativo reabre a aba sozinho quando a libera por inatividade, e seria ele criando o incômodo. Marcando "Lembrar a senha deste arquivo" no próprio pedido, ela passa a valer também nas próximas execuções: fica protegida pelo Windows (só para você, só nesta máquina), nunca vai para o Git nem para a nuvem, e não é levada pela exportação de configurações. Para apagar todas: Configurações → Recursos → Senhas de PDF. Um PDF protegido não é reaberto sozinho ao iniciar o aplicativo — em vez de enfileirar pedidos de senha antes de mostrar a janela, ele espera você abri-lo.

No menu de ações da barra: copiar o texto da página, exportar o texto do documento inteiro, copiar ou salvar a página como imagem e enviar a página para a nota do dia. O painel Links existe porque o componente de PDF do Qt navega sozinho os links internos, mas ignora os externos — é por ali que se abre um endereço da web, com confirmação.

Limitação: não há seleção de texto com o mouse, porque o componente de PDF do Qt não a oferece. Para levar o conteúdo embora, use "copiar o texto desta página" ou a exportação do documento.

Imagens: marcar um print

Uma imagem abre numa aba com barra própria: além de girar, espelhar e ampliar, ela traz as ferramentas de marcação — o caminho de dar um print, apontar o que importa e levar embora para a documentação.

A ferramenta inicial é Mover: arrastar continua movendo a imagem, como sempre foi. Selecionar escolhe uma parte — arraste para criar, arraste por dentro para deslocar e use as alças dos cantos e das bordas para redimensionar; Esc desmarca e Del apaga o conteúdo da região. No modo Mover, Shift+arrastar também seleciona. Em qualquer ferramenta, o botão do meio do mouse move a imagem.

O Conta-gotas pega uma cor da própria imagem: botão esquerdo joga na cor da borda, botão direito na de preenchimento. Ele lê da imagem já marcada, então serve para repetir a cor de uma marca que você acabou de fazer.

As demais desenham: Retângulo, Elipse, Seta, Linha, Realce (translúcido, como marca-texto), Caneta (traço livre), Pincel, Passo numerado (que se numera sozinho — 1, 2, 3...), Texto, Borrar e Foco (escurece tudo menos a região escolhida). Ao desenhar, Shift trava quadrado/círculo e ângulos de 45°.

São duas cores, em dois botões: a da borda (que também é a do traço e a do rótulo) e a de preenchimento, que pode ser nenhuma. Sem preenchimento, o retângulo e a elipse saem só de contorno, e o passo numerado e o texto usam a cor da borda como fundo, com o rótulo em branco ou preto — o que contrastar. Escolhendo um preenchimento, ele vira o interior da forma e o fundo do rótulo, e a borda passa a ser a cor do texto.

O Pincel pinta com o preenchimento, numa marca do tamanho da espessura — redonda ou quadrada, pelo botão ao lado da espessura. Um clique já deixa a marca. Com o preenchimento branco, ele é a borracha: tapa o que estiver embaixo.

A espessura vale para o traço, o tamanho do rótulo e o tamanho do bloco do borrar; ela fica esmaecida nas ferramentas que a ignoram. Cor e espessura são lembradas entre sessões. Ctrl+Z e Ctrl+Y desfazem e refazem as marcações, e Limpar marcações apaga todas de uma vez (também desfazível).

Borrar é para esconder (um token, um e-mail, um caminho). Enquanto a aba está aberta a marcação é reversível, mas ao salvar ou copiar os pixels daquela região são realmente destruídos: o arquivo que sai não guarda o original em lugar nenhum.

Três operações têm nomes parecidos e fazem coisas diferentes. Recortar (Ctrl+X) copia a seleção para a área de transferência e apaga a região, pintando-a com a cor de preenchimento (branco quando não há) — e a seleção continua ali, de modo que Colar logo em seguida devolve a peça exatamente no lugar de onde saiu, flutuando: é assim que se move um pedaço da imagem. Del é o recortar sem copiar. Já Manter só a seleção, no menu Imagem, faz o oposto: fica com a região e joga o resto fora, mudando o tamanho da imagem.

O resto da família: Copiar leva a imagem marcada ou só a seleção; Colar traz a imagem da área de transferência como uma colagem flutuante — mova e redimensione pelas mesmas alças e clique fora (ou tecle Enter) para gravá-la, Esc descarta; e Ctrl+A (ou Ctrl+T) seleciona a imagem inteira. Há ainda Salvar (grava as marcações no próprio arquivo), Salvar como... e Enviar para a nota do dia, que grava o PNG em Anexos/ e insere o ![]() na nota. Enquanto houver marcação não salva a aba fica com o asterisco, e fechá-la pergunta se você quer salvar.

O botão Imagem reúne o que mexe na figura inteira: girar, espelhar, redimensionar por porcentagem, reduzir para 1600 / 1200 / 800 px de largura (um print de tela nasce grande demais para a documentação), aparar bordas de cor uniforme, adicionar margem, sombra projetada e gravar as marcações na imagem — este último transforma as marcas em pixels na hora, que é o que permite borrar por cima de uma marca. Redimensionar leva as marcações e a espessura do traço junto.

Para capturar a tela sem sair do LightNote: Capturar tela... no menu da bandeja (ou Ctrl+Alt+P) congela o desktop, você arrasta para escolher a área (Esc cancela) e o recorte abre numa aba nova, já pronto para marcar.

Limitações: uma marcação já desenhada não se move nem se edita — apague com Ctrl+Z e refaça; GIF e WebP animados abrem na visão de animação, que não tem marcação; e um .svg é rasterizado na leitura, então salvar pede um destino em PNG.

Zip como pasta (.zip)

Um .zip abre numa aba própria: à esquerda a árvore dos membros (nome, tamanho, data), à direita o conteúdo do membro selecionado — texto/código, Markdown (com preview), imagem ou PDF — aberto em memória, sem extrair nada para o disco. Texto e Markdown podem ser editados: Ctrl+S regrava o membro dentro do próprio .zip.

A mesma aba abre .7z, .rar, .tar (inclusive .tar.gz, .tar.bz2 e .tar.xz), .cab e .iso — nesses casos somente leitura: dá para navegar, visualizar e extrair membros, mas não editar. Só o .zip é gravável, porque é o único formato que sabemos reescrever com segurança (o .rar é proprietário e nem as bibliotecas livres o comprimem).

Imagem e PDF são somente leitura; membros muito grandes (e .parquet) só oferecem Extrair para…. Não dá para criar, renomear ou apagar membros.

Membros protegidos por senha são lidos normalmente: ao abrir um deles o LightNote pede a senha (até três tentativas) e, marcando "Lembrar a senha deste arquivo", não pergunta de novo — na mesma execução por padrão, e também nas próximas se a caixa for marcada (protegida pelo Windows, só para você nesta máquina; apague todas em Configurações → Recursos). Note uma diferença do formato em relação ao PDF: no .zip a cifra é por membro e o índice fica em texto claro, então a lista de arquivos aparece inteira mesmo sem a senha — só o conteúdo é protegido. Um .zip com membros cifrados não é reaberto sozinho ao iniciar o aplicativo.

zip-password

Blocos (.lnb)

Um bundle de Blocos é uma pasta cujo nome termina em .lnb, tratada como um item único na árvore (duplo clique abre). Cada bloco é um arquivo real no disco; a ordem fica num blocks.json na raiz do bundle. É como um caderno: células empilhadas de código ou texto.

Cada célula tem nome, botão de tipo (define o interpretador/lexer) e botões para copiar, incluir, apagar e executar. Executar até aqui roda em sequência todas as células de código até a atual; a saída (stdout+stderr) aparece num painel logo abaixo da célula. Crie um pela árvore (Novo) ou em Arquivo → Novo.

Ctrl+Enter executa a célula com o foco — o mesmo gesto do editor SQL.

O resultado fica gravado (como num caderno de laboratório): ao terminar, cada execução vira um arquivo .md dentro de saida/<célula>/, no próprio bundle — com o instante, o código de saída, a duração, o comando e a saída em si. Como é Markdown, dá para ler em qualquer editor, versionar no Git junto do caderno e recuperar pela busca nas notas. Reabrir o bundle traz de volta a faixa Última execução acima do painel: clique nela para ver o resultado sem rodar de novo.

Histórico: o botão Histórico ao lado dessa faixa lista as execuções anteriores daquela célula (instante e código de saída) — útil para comparar o que a mesma célula devolveu ao longo do tempo. Guardamos as 10 mais recentes por célula; para mudar, edite a chave historyLimit no blocks.json do bundle (0 desliga a gravação). Saída muito grande é cortada (o arquivo diz truncated: true). Renomear a célula ou trocar seu tipo leva o histórico junto; apagar a célula manda o histórico para a Lixeira.

Célula SQL num banco de verdade: aponte o caderno para uma conexão .lnc pela barra no topo (Escolher conexão…) e as células do tipo sql passam a executar no banco, e não por um interpretador. O resultado de um SELECT vira uma tabela no arquivo de saída (Markdown de verdade, que qualquer visualizador mostra formatada); INSERT/UPDATE e afins reportam quantas linhas mudaram, e um erro do banco interrompe o script e registra a instrução que falhou. Trazemos até 100 linhas por consulta (o arquivo avisa quando há mais) — o resultado é uma anotação, não uma cópia da tabela.

A conexão fica no blocks.json como caminho relativo, então o caderno continua funcionando ao mover ou sincronizar a pasta. Se preferir um caderno auto-contido, guarde o próprio .lnc dentro do bundle: ele conta como configuração, não vira célula. A conexão é a mesma da aba de Banco de Dados — conectar num lugar vale no outro, e a senha segue as regras da Frase-Segura. Sem conexão apontada, a célula sql continua rodando pelo interpretador configurado, como antes.

Tarefas (Kanban / Gantt)

Um bundle de Tarefas (.lnt) abre um quadro de tarefas com visões de Kanban (colunas de status, arraste os cartões), Gantt (cronograma por esforço) e calendário. Cada tarefa pode ter título, coluna (status), esforço em horas e uma nota .md associada. As tarefas são acessíveis também por IA, via MCP e CLI (criar, mover, atualizar, ler/gravar a nota).

Campos por tarefa: além de status e esforço, cada tarefa tem prioridade (colore a borda do cartão e ordena a Tabela), data de vencimento (chip vermelho quando atrasada), múltiplas etiquetas, checklist de subtarefas (badge de progresso no cartão) e recorrência (concluir uma tarefa recorrente gera a próxima ocorrência). Edite-os no menu de contexto (Tabela/Kanban) e no painel Propriedades.

Captura e listas: a Tarefa rápida da bandeja entende linguagem natural (ex.: Pagar conta amanhã 17h #casa !alta). O botão Modelos salva/aplica modelos de tarefa; Listas por vencimento filtra Hoje/Próximos 7 dias/Atrasadas; Visões salvas guarda filtro+ordenação; e a bandeja/Launcher mostram lembretes de tarefas que vencem hoje ou estão atrasadas.

Quadro Kanban: dá para agrupar as colunas por status, prioridade ou etiqueta, criar raias (swimlanes), definir limites de WIP por coluna (cabeçalho fica vermelho ao exceder) e ordenar os cartões. Navegação por teclado no estilo Linear: ←/→ movem o foco, Ctrl+←/→ movem o cartão, N cria, Espaço conclui/reabre e Delete exclui. Há ainda a visão Calendário (por data de vencimento).

Nota embutida: selecionar uma tarefa mostra a nota .md ao lado das vistas (autosalva ao trocar de tarefa); o botão Nota liga/desliga o editor e Abrir nota em aba abre numa aba própria. Arquivar uma tarefa a esconde de todas as vistas; o toggle Mostrar arquivados revela as arquivadas (esmaecidas).

Nas Configurações das Tarefas você define Arquivar tarefas concluídas após N dias: ao abrir o quadro, as tarefas que ficaram na coluna final por mais tempo que isso são arquivadas automaticamente (0 = desligado).

A nota abre embutida por padrão (duplo-clique na tarefa) e salva sozinha enquanto você escreve — as Tarefas nunca perguntam "salvar?" ao fechar. Dentro da nota valem as ações de IA (Ctrl+K / Ctrl+I).

Barra da aba. As ações que dependem da tarefa selecionada (Excluir, Dependências, Histórico (Git)) e o Exportar CSV ficam no botão ⋮. O botão Visões reúne as listas por vencimento, as visões salvas e o mostrar arquivadas — todos agem sobre a Tabela. Ctrl+F foca o filtro rápido e o contador à direita mostra quantas tarefas o filtro deixou.

Tabela personalizada (.lnd)

Uma Tabela personalizada (.lnd, em Arquivo → Novo) é a sua mini-base de dados: você define as colunas em tempo de execução — texto, número, data, lista fixa com cor, caminho, tags e senha — e preenche as linhas como numa planilha, com ordenação e filtro. Um campo de caminho agrupa as linhas numa árvore (ex.: Casa/Escritório).

Células de senha são cifradas individualmente com a Frase-Segura e reveladas sob demanda. Como nas Tarefas, o bundle persiste em texto (NDJSON) amigável ao Git — dá para versionar e mesclar entre máquinas.

Em colunas de texto, abrir uma célula mostra um editor multilinha flutuante: Enter quebra a linha e Ctrl+Enter confirma; na grade o texto aparece em uma linha só (com …) e o conteúdo completo vem no tooltip. Para mudar o tipo de uma coluna, use o menu do cabeçalho: ao converter texto → senha os valores são cifrados com a Frase-Segura; ao converter senha → texto o LightNote pede confirmação e o PIN/Frase e grava o conteúdo em texto puro (irreversível). Demais conversões preservam os valores.

Bases (consultas salvas sobre as notas)

Uma Base (.lnq, em Arquivo → Novo → Nova Base) é uma consulta salva sobre as suas notas: filtre por tipo e por propriedades e veja o resultado como tabela ou quadro. A Base não guarda dado nenhum — as linhas são as suas notas .md e a fonte da verdade de cada célula é o frontmatter da nota. Apagar um .lnq não perde nota alguma.

Editar a célula grava na nota. Na tabela, alterar uma propriedade reescreve só aquela linha do frontmatter do arquivo. No quadro, arrastar um cartão de uma coluna para outra grava o novo valor da propriedade de agrupamento (ex.: mover de lendo para lido).

Cada nota declara suas propriedades no frontmatter (type, status, autor…). Use a mini-barra Propriedades da nota para editá-las como campos tipados (texto, número, data, caixa de seleção) em vez de YAML cru — veja Notas em Markdown.

O .lnq é NDJSON (um registro por linha), pensado para o Git: duas máquinas podem editar a mesma Base em paralelo — uma acrescenta uma coluna, a outra ajusta um filtro — e o merge junta as duas mudanças sem conflito.

Esquema declarado (opcional). Por padrão o LightNote infere os campos de cada tipo a partir do que as notas já usam — você não precisa declarar nada. Quando quiser fixar o esquema, abra Ferramentas → Tipos de nota... (ou o botão de engrenagem da mini-barra Propriedades da nota): declare os campos de cada tipo, o seu tipo de dado (texto, número, data, caixa de seleção, lista de opções) e um modelo padrão. Com o esquema, um campo de lista de opções vira uma caixa de seleção com os valores permitidos, os campos declarados aparecem nos seletores de coluna e filtro da Base mesmo antes de qualquer nota usá-los, e o botão Aplicar modelo do tipo traz o esqueleto da nota. O esquema vive em .lightnote/types.ndjson — NDJSON mergeável, versionado no Git com as notas; apagá-lo não altera nota nenhuma, só volta a inferência.

Busca em arquivos e Pendências

Use Ctrl+Shift+F para a busca global na aba Buscar da barra lateral, apoiada no ripgrep: aceita regex, diferenciar maiúsculas, palavra inteira e substituição em massa. Dentro do arquivo atual, Ctrl+F localiza e Ctrl+H substitui.

Realce e marcas são coisas diferentes. A busca rápida (Ctrl+F) apenas realça as ocorrências em âmbar: é temporário e some ao fechar a barra ou limpar o campo. Já o Marcar tudo de Editar → Localizar avançado… é uma decisão sua — pinta as ocorrências em vermelho e acrescenta o marcador (a bolinha azul na margem) nas linhas correspondentes, que ficam até você usar Limpar marcas. Os dois são independentes: fechar a busca rápida não apaga o que você marcou, e limpar as marcas não apaga o realce da busca. Ambos aparecem na faixa do minimap, cada um na sua cor.

A seção Pendências da barra lateral reúne num só lugar os TODO/FIXME do código e as tarefas (- [ ]) das notas Markdown do espaço de trabalho — clique para ir direto à linha.

Versionamento (Git fácil)

O versionamento é opt-in por espaço de trabalho. Ative em Ferramentas → Configuração do Espaço de Trabalho: o LightNote cria o repositório Git (se ainda não existir) e mostra a barra lateral de versionamento (Ctrl+Shift+G).

No modo automático, o LightNote salva versões (commits) sozinho nos momentos escolhidos nas Configurações Gerais (ao salvar, ao fechar a aba ou ao fechar a janela). No modo manual, você escreve a mensagem e salva a versão no painel. O indicador na barra de status mostra o estado (sem alterações, X alterados…) e, ao ser clicado, abre a configuração do espaço. Dá para ver o diff de cada arquivo e restaurar (descartar) mudanças não salvas.

A automação tem 3 níveis por pasta (em Configuração do Espaço de Trabalho): Manual (nada automático), Commit automático (salva versões sozinho, mas não sincroniza) e Tudo automático (commita e sincroniza — push após o commit + pull periódico; exige credenciais de Git sem prompt). O painel mostra uma linha de estado com ↑ a enviar / ↓ a receber em relação ao remoto, e o botão principal muda de commit para Sincronizar quando há versões a enviar — assim fica claro que, depois de salvar, ainda falta sincronizar.

No painel e no menu Git da árvore há Adicionar (git add) e Restaurar (git restore) por arquivo, além de Comparar lado a lado (arquivo inteiro contra a última versão).

Snapshots e backup

No menu ⋯ do painel de versionamento (ou em Ferramentas):

  • Criar snapshot: marca o estado atual com uma etiqueta de data/hora para você voltar a ele depois.
  • Restaurar snapshot: escolha um snapshot e o que fazer — trazer os arquivos mantendo o histórico (recomendado), voltar o histórico àquele ponto, ou abrir como uma cópia separada.
  • Exportar cópia (.zip): compacta o espaço de trabalho inteiro num arquivo autocontido (com o marcador de projeto embutido) para enviar ou guardar fora.
  • Mover pasta do Espaço de Trabalho…: move a raiz no disco e ajusta os caminhos da sessão e do registro.

Revisar mudanças (checkpoints)

Ferramentas → Revisar mudanças… mostra, numa aba só, o diff agregado de tudo que mudou no espaço de trabalho desde uma base: a lista de arquivos adicionados/modificados/apagados à esquerda e o diff do arquivo selecionado à direita. Foi pensado para revisar o que uma sessão de CLI de IA alterou antes de aceitar o trabalho.

A base pode ser a última versão (HEAD) ou um checkpoint: crie um antes de começar uma tarefa (botão na própria aba) e compare depois contra ele. Os checkpoints não criam commits nem mexem no seu histórico. Requer o versionamento ativo na pasta.

Comentar em lote. Na revisão de uma sessão de IA, o botão Comentar (também no menu de contexto da lista de arquivos) anota um comentário sobre o arquivo selecionado — ancorado no trecho que você marcar. Os comentários se acumulam numa lista e só vão ao terminal da CLI quando você clica em Enviar à sessão, todos numa mensagem só. Isso é deliberado: enviar um de cada vez faz o agente corrigir um problema e quebrar outro, porque cada rodada não enxerga as demais críticas. Depois que ele revisa, os comentários continuam na lista para você conferir se foram atendidos; marque os resolvidos e o que sobrar entra no próximo envio. Se o agente reescrever a região comentada, o comentário fica esmaecido em vez de sumir. O envio é confirmado na barra de status, e uma sessão hibernada é retomada automaticamente para receber o lote.

Comparar arquivos (diff)

Ferramentas → Comparar dois arquivos… abre os dois lado a lado (dois editores) e marca as diferenças linha a linha. A comparação é somente leitura.

Os botões ◀ / ▶ (ou F8 / Shift+F8) pulam para a alteração anterior/seguinte. Pelo painel Git também dá para comparar um arquivo lado a lado com a versão salva (HEAD × disco).

Executar código (F5)

Ferramentas → Executar arquivo (F5) salva o arquivo atual e o roda no terminal, conforme o interpretador registrado para a extensão. Os padrões cobrem .py, .sh, .bat, .cmd e .sql; você pode editar/adicionar interpretadores em Configurações → Execução.

O comando é um template com {arquivo}, {pasta} e {nome} — por exemplo, para Python: python {arquivo}. Também dá para enviar só a seleção/linha atual ao terminal com Ctrl+Shift+Enter. Nos Blocos, cada célula roda pelo mesmo mecanismo.

O botão Executar tem uma seta para escolher e lembrar o terminal-alvo quando há mais de um terminal aberto.

Erros clicáveis. No painel de saída (F6), as referências a arquivo:linha viram links: Ctrl+clique ou duplo-clique abre o arquivo no ponto exato. Funciona com traceback do Python, pilha do Node, erros de compilador (gcc/clang/MSVC) e saída de linters. Só vira link o que existe de fato no disco — o resto continua sendo texto.

Percorrer os erros. No painel de saída, F8 pula para o próximo erro e Shift+F8 para o anterior (também há botões na barra do painel). O salto é circular: rola a saída até a referência, realça o trecho e abre o arquivo no ponto exato.

Terminal e CLIs de IA

Bolinha de status por comando. Ao lado de cada comando executado aparece uma bolinha: azul se teve sucesso, vermelha se deu erro (o tooltip mostra a hora, a duração e o código de saída). O LightNote ativa isso automaticamente no PowerShell e no Git Bash, sem alterar sua configuração — ligue/desligue em Configurações → Terminal → Integração de shell. Outros shells (cmd, WSL) ou comandos personalizados não mostram a bolinha.

Abra um terminal integrado (emulador VT completo, via ConPTY) com Ctrl+' (no layout de teclado US, também Ctrl+`). Ele vira uma aba e pode ser movido entre as áreas da janela. Os shells disponíveis e as CLIs de IA detectadas no PATH (ex.: claude) são configuráveis em Configurações → Terminal e Configurações → Assistentes de IA. No menu Novo terminal, escolher uma CLI de IA abre essa CLI como o terminal — a TUI/cores aparecem normalmente, e sair dela fecha a aba.

Agendar envio. No menu de contexto do terminal (botão direito), Agendar envio… permite mandar um Enter (ou um texto) mais tarde — útil para retomar uma CLI de IA quando o limite de uso reabre, sem ficar de olho. Escolha o gatilho: em um horário, após alguns minutos, a cada intervalo (recorrente) ou quando o terminal ficar ocioso. O computador é mantido acordado até o disparo. O agendamento vale enquanto a aba do terminal estiver aberta.

Você pode ter vários agendamentos ao mesmo tempo. Quando há algum, o item de menu passa a mostrar Envios agendados (N)… e abre um gerenciador: uma tabela com o terminal, o que será enviado, quando, e uma contagem regressiva ao vivo até o próximo disparo, com botões para Novo, Editar e Remover. Enquanto houver agendamentos, um indicador de relógio com a contagem aparece na barra de status (clique nele para abrir o gerenciador) e um pequeno relógio marca a aba do terminal que está armado.

Aviso de fim de turno da IA. Quando um terminal de CLI de IA fica em silêncio — sinal de que o agente terminou o turno — o LightNote avisa: um toast aparece (clique nele para focar aquele terminal) e a aba pisca algumas vezes e mantém um destaque até você abri-la. Se a janela estiver em segundo plano, o botão dela também pisca na barra de tarefas. O aviso vale só para terminais de CLI de IA e só quando a aba não está em foco. Ligue/desligue e ajuste o tempo de silêncio em Configurações → Terminal → Aviso de fim de turno da IA.

Os terminais voltam com a janela. Ao fechar e reabrir o espaço de trabalho, os terminais de shell comum (Prompt, PowerShell, Bash) são reabertos — e na pasta em que você estava, não naquela em que o terminal abriu. O conteúdo da tela não volta, mas o histórico de comandos é do próprio shell e continua lá: a seta ↑ funciona normalmente. Sessões de assistente de IA ficam de fora e continuam sendo oferecidas à parte, porque um terminal novo não é a mesma conversa. Também não voltam variáveis de ambiente nem ambientes ativados à mão naquela sessão (um venv, por exemplo): o terminal reabre na pasta certa, mas é um shell novo.

Assistente de IA na seleção (Ctrl+K / Ctrl+I)

IA padrão. No topo de Configurações → Assistentes de IA, a IA padrão escolhe o assistente usado pelo Ctrl+K/Ctrl+I, pelo chat Chat com IA (que você pode trocar por sessão) e pelas tarefas automáticas (reescrever a pergunta, resumir, resumo de áudio, gerar contexto). Ela lista tanto as CLIs quanto os provedores de API. Já a transcrição de áudio e os embeddings têm provedor próprio, e o LightNote sugere um modelo conforme o provedor escolhido.

Pressione Ctrl+K (Perguntar à IA) ou Ctrl+I (Editar com IA) no editor — com ou sem seleção — para abrir um popup flutuante estilo "inline chat": o campo de prompt já vem com a seleção abaixo de uma linha em branco; digite a instrução por cima e envie com Ctrl+Enter. No popup você escolhe a IA (a padrão vem pré-selecionada) e o modo de resultado: substituir a seleção vendo um diff (Original × Sugestão, com Aceitar / Copiar / Rejeitar) ou apenas exibir a resposta como texto.

O LightNote roda a CLI de IA em modo "one-shot" (sem abrir terminal). As CLIs e a IA padrão ficam em Configurações → Assistentes de IA.

Modelos por API. Além das CLIs locais, você pode cadastrar modelos de LLM por API compatível com OpenAI (OpenAI, Groq, DeepSeek, OpenRouter, Gemini, Anthropic, instâncias locais como Ollama/LM Studio…) em Configurações → Assistentes de IA. Escolha um provedor do catálogo (já com a URL pronta), cole a chave (guardada codificada só nesta máquina), use Buscar modelos… e Testar. Os modelos cadastrados aparecem no mesmo seletor do Ctrl+K, ao lado das CLIs.

Conectar em um passo. O caminho normal não é preencher a tabela: em Configurações → Assistentes de IA, clique em Conectar uma IA…, escolha o provedor (a lista marca quem tem plano gratuito e quem roda no seu computador, sem chave), siga os três passos, abra a página de chaves no botão e cole a chave. O LightNote preenche o endereço e o modelo sozinho e testa a conexão antes de salvar — chave errada aparece ali, não no meio de uma conversa. A lista de cima mostra o que já está conectado e, no que falta algo, o que falta (“falta colar a chave”, “falta escolher o modelo”); um duplo clique reabre o assistente naquele provedor.

Ajustes finos. Endereço, modelo, permissão de MCP, comandos das CLIs, transcrição de áudio e embeddings continuam todos disponíveis em Avançado, no fim da página — e dentro do próprio assistente, em Opções avançadas, dá para mudar a URL base e o modelo antes de conectar. Nada foi removido: só saiu da frente de quem está começando.

Sem nenhuma IA ainda? Ao usar Ctrl+K sem nenhum assistente conectado, o LightNote explica e oferece conectar um na hora — e, assim que você conecta, a ação que você pediu continua, sem precisar repetir o atalho.

LLM local (sem chave). Provedores locais — Ollama, LM Studio, llama.cpp — dispensam chave de API: escolha um deles em Adicionar (o seletor mostra se o servidor está em execução) e use Buscar modelos… para escolher entre os modelos que você já baixou. Se o Ollama não estiver instalado, o LightNote oferece instalá-lo por você. Ele já vem cadastrado na primeira execução — falta só escolher o modelo. Como um modelo local pode demorar bem mais para responder (sobretudo na primeira geração, quando o modelo é carregado), o LightNote espera muito mais por ele do que por um serviço na nuvem. Nenhum texto seu sai da máquina.

Aceitar por trecho. Quando o resultado vem em modo diff, você não precisa aceitar tudo: cada bloco alterado tem uma caixa para incluir ou não aquela mudança, e o texto final é remontado só com os trechos marcados. O prompt também leva contexto automático do arquivo (caminho, linguagem e as linhas ao redor da seleção), para a IA responder com mais precisão sem você colar nada.

Biblioteca de prompts. IA → Biblioteca de prompts… guarda prompts reutilizáveis como arquivos .md numa pasta Prompts/ do seu espaço de trabalho — formato aberto, versionável no Git e parte do seu segundo cérebro. O seletor traz busca, pré-visualização e um botão para criar um prompt novo. Ao escolher um, os campos {seleção}, {arquivo}, {pasta}, {nome} e {linguagem} são preenchidos com o contexto do editor atual (variáveis suas são preservadas), e o texto é injetado no campo do Ctrl+K ou enviado ao terminal de IA ativo, sem submeter.

Não só no editor de código. As ações de IA (Ctrl+K / Ctrl+I e o menu de contexto) valem também no editor de Markdown, na nota embutida das Tarefas e no editor de consultas SQL do banco — em cada um o popup abre sobre o cursor e aplica o resultado no lugar.

Todas as ações de IA vivem no menu IA (no botão ☰ e no botão da varinha, na barra de atividades): Perguntar à IA (Ctrl+K), Editar com IA (Ctrl+I), Sessões de IA, Chat com IA, Biblioteca de prompts, Gerar arquivo de contexto do projeto, Ativar IA nesta pasta e Configurar assistentes de IA.

Sessões de IA

IA → Sessões de IA… abre um cockpit que lista, num cartão por sessão, cada terminal de CLI de IA aberto em qualquer janela do LightNote — com uma bolinha colorida do estado, o nome da CLI, a janela e selos para o que precisa de atenção (envios agendados, cópia isolada). O duplo clique foca o terminal; o menu ⋯ do cartão (ou o botão direito) traz Revisar as mudanças daquela sessão (abre a tela de revisão já com a base no checkpoint criado quando a sessão começou — veja Revisar mudanças) e Agendar um envio. É a forma de acompanhar várias sessões de "vibe coding" ao mesmo tempo sem se perder entre as janelas.

Ao abrir uma CLI de IA como terminal num repositório Git, o LightNote grava automaticamente um checkpoint (rótulo "Sessão …"), para que você possa depois ver e reverter exatamente o que aquela sessão alterou. O recurso pode ser desligado em Configurações → Geral → Recursos.

Cópia isolada (worktree): em pastas com Git, o LightNote pode rodar o assistente de IA numa cópia isolada da pasta (um branch próprio), sem alterar os arquivos que você edita à mão. Na primeira vez ele pergunta; depois é automático (você liga/desliga por pasta em Configuração do Espaço de Trabalho → Integrações). Um selo cópia isolada marca a sessão (o branch e o caminho ficam na dica ao pousar o mouse), e os itens Mesclar… (traz as mudanças para a sua pasta — se você tiver alterações pendentes, ele pergunta antes) e Descartar… (joga fora a cópia e o branch) cuidam do fim do ciclo.

Aviso de sessão ociosa. Quando uma CLI de IA fica ociosa (terminou ou está aguardando você), o LightNote mostra uma notificação; clicar nela abre a revisão das mudanças daquela sessão. Assim você pode iniciar a tarefa e sair de perto. Pode ser desligado em Configurações → Terminal.

Arquivo de contexto do projeto. Ao abrir uma CLI de IA numa pasta sem um arquivo de contexto (CLAUDE.md ou AGENTS.md), o LightNote oferece gerar um — e você pode fazê-lo a qualquer momento por Ferramentas → Gerar arquivo de contexto do projeto…. Um bom arquivo de contexto descreve a estrutura e as convenções do projeto e ajuda a IA a errar menos, sem você reexplicar tudo a cada sessão. Se houver um provedor de IA configurado, o conteúdo é gerado por ele; senão, um esqueleto para você preencher.

Hibernar sessões ociosas. Uma CLI de IA parada continua ocupando memória (a conversa e o cliente do modelo). Em Configurações → Terminal você pode definir um tempo de silêncio após o qual o LightNote encerra o processo e o retoma sozinho quando você voltar àquela aba — o histórico do terminal continua na tela. Vem ligado, com 30 minutos: três sessões paradas do Claude Code chegaram a segurar mais de 1 GB na medição; e só vale para sessões em cópia isolada cujas CLIs sabem retomar a conversa da pasta (hoje Claude Code e Antigravity), porque sem isso a retomada traria a conversa de outra sessão. Uma sessão com envio agendado nunca hiberna. E o que volta é a conversa, não a tela da ferramenta: um texto digitado e ainda não enviado se perde.

Aba Atividade. A tabela mostra o que está rodando agora; a aba Atividade guarda o histórico: cada vez que um agente terminou o turno, começou numa cópia isolada ou hibernou, com a data e um trecho da última resposta. Os itens não lidos aparecem em negrito e a contagem também surge no menu da bandeja — assim quem saiu de perto do computador vê o que perdeu, já que as notificações são passágeiras. Abrir a aba marca tudo como lido; um clique duplo leva de volta à sessão. O encerramento da sessão também vira evento — inclusive quando a CLI sai sozinha —, então uma sessão que morreu enquanto você estava longe deixa rastro em vez de simplesmente sumir. Se a sessão do evento já não estiver aberta, o clique duplo diz isso em vez de não fazer nada.

Chat com IA

IA → Chat com IA… abre um chat que responde usando as suas próprias notas como contexto. Em vez de mandar tudo para a nuvem, o LightNote recupera os trechos mais relevantes do seu vault localmente (via ripgrep, sem depender de embeddings nem de serviço externo), monta a pergunta com esses trechos e a envia a um provedor de IA por API que você tenha cadastrado. A resposta vem com as notas-fonte como citações clicáveis — clique para abrir a nota. Ótimo para "conversar com o seu segundo cérebro" e reencontrar o que você já anotou. O histórico da conversa fica só na memória (não é salvo); o recurso pode ser desligado em Configurações → Geral → Recursos.

A janela. Os seletores ficam numa faixa única no topo: a IA, a pasta das notas e — quando há um editor de texto ativo — o contexto; à direita ficam as duas permissões (Ferramentas e Permitir alterações) e o botão +, que começa uma conversa nova. Antes da primeira pergunta, a tela diz sobre o que a janela vai responder e oferece atalhos de um clique, como Resumir esta pasta. No campo de pergunta, Enter envia e Shift+Enter quebra a linha; enquanto a resposta vem, o botão de envio vira Parar.

Deixar a IA usar ferramentas. A caixa Permitir alterações muda o funcionamento: em vez de responder só com os trechos que a busca por termos recuperou, o modelo passa a procurar sozinho — ler um arquivo, pesquisar notas, listar tarefas — e só então responder. Ao ligar, o LightNote testa na hora se o modelo escolhido sabe chamar ferramentas: muitos provedores aceitam o pedido e simplesmente ignoram as ferramentas, o que sem essa verificação viraria uma resposta inventada com cara de consultada. O teste é lembrado por sete dias para cada par provedor+modelo. Exige um provedor por API (uma CLI local não tem como receber ferramentas). No fim da resposta aparece a lista do que foi efetivamente usado, para você julgar a resposta em vez de confiar nela. Se o veredito for negativo — o provedor pode simplesmente ter ficado fora do ar naquele instante —, aparece um botão Verificar de novo ao lado da mensagem, que refaz o teste ignorando o que ficou guardado.

Deixar a IA alterar as suas coisas. A segunda caixa, Permitir alterações, é um passo à parte e vem desligada. Com ela, a IA também pode criar notas e tarefas, mudar propriedades e anotar na nota do dia — mas nada acontece sem a sua confirmação: a alteração aparece na conversa em português claro ("criar a tarefa Comprar pão"), com Permitir e Recusar. Recusar não encerra a conversa; o modelo é avisado e segue explicando ou propondo outro caminho. Ler nunca pede confirmação — só alterar. Ficam de fora, de propósito, sobrescrever arquivos quaisquer e acessar a rede: enquanto a IA só lê, um texto mal-intencionado que chegue numa nota sincronizada de fora não tem como virar mudança no seu disco. Quando a alteração é uma anotação na nota do dia, o pedido também diz em que pasta ela vai cair — é a única escrita cujo arquivo de destino não está no que a IA pediu.

Notas ou o arquivo aberto. O combo Contexto:, no topo da janela, escolhe sobre o que a conversa é: Notas do vault (o padrão, descrito abaixo) ou Editor atual — que responde sobre o arquivo aberto no editor em vez do vault, usando a seleção e o trecho ao redor (ou o arquivo inteiro, com a caixa Arquivo inteiro). Assim o mesmo chat serve para conversar sobre as suas notas e sobre o código que você está editando, em vários turnos. O escopo Editor atual só aparece quando há um editor de texto ativo. E, no assistente rápido (Ctrl+K), o resultado traz um botão Continuar no chat → que reabre esta janela já no escopo Editor atual, semeada com a pergunta e a resposta daquela rodada — para aprofundar sem recomeçar.

De quais notas? A janela é única e responde sobre uma pasta por vez — o combo Notas de:, ao lado do seletor de IA na faixa do topo, mostra e escolhe qual. Ele já vem apontado para a pasta da janela de onde você abriu o chat e lista as pastas abertas agora, seguidas das recentes; Escolher pasta… aponta para qualquer outra. Trocar a pasta vale para as próximas perguntas — inclusive para perguntar às notas de um projeto enquanto você trabalha em outro. Escolhida à mão, a pasta continua valendo até você trocá-la de novo (reabrir a janela não puxa o escopo de volta). Enquanto uma pergunta está em andamento — inclusive parada esperando a sua confirmação —, os seletores de IA, de contexto e de pasta ficam travados: a resposta que está vindo pertence ao modelo e à pasta de quando você perguntou.

Como perguntar. A recuperação é por assunto, não por instrução: o LightNote extrai as palavras da sua pergunta e procura as notas que as contêm. Cite um tema que apareça nas notas ("o que anotei sobre Postgres?") em vez de um pedido genérico ("faça um resumo") — este último não tem nenhuma palavra de conteúdo para buscar, então nada é recuperado e o chat avisa que a resposta não usou as suas notas. Só notas .md/.markdown são lidas; numa pasta sem nenhuma delas o chat avisa e não gasta uma chamada de IA.

Busca melhor, resumo e reescrita. A recuperação usa um índice local com ranqueamento BM25 que ignora acentos ("configuração" acha "configuracao") e funciona também em idiomas sem espaço entre palavras (japonês, chinês, coreano) — o ripgrep é o reforço quando o índice ainda está sendo montado. O botão Resumir esta pasta gera um panorama de todas as notas quando você não tem uma pergunta específica. E, em Configurações → Geral → Recursos, a opção Reescrever a pergunta com IA amplia a sua pergunta em palavras-chave antes de buscar (custa uma chamada de API por pergunta).

Basta uma chave. Na primeira execução, o LightNote já deixa OpenAI, Google Gemini e Anthropic (Claude) cadastrados em Configurações → Assistentes de IA — só falta colar a sua chave de API no provedor que você usa. Se nenhum provedor tiver chave, a janela mostra um botão Configurar agora que abre essa tela direto.

Conversas ficam guardadas. O botão de relógio no topo abre a lista de conversas anteriores daquela pasta: clique numa para voltar a ela. Nova conversa arquiva a atual em vez de apagá-la, e o botão direito na lista apaga uma conversa de vez (com confirmação). As conversas são guardadas por pasta — trocar a pasta de notas troca a lista.

O que fazer com uma resposta. Sob cada resposta há Copiar (põe o texto em Markdown na área de transferência, com a formatação intacta) e Capturar na nota (manda a resposta para a nota do dia, junto com links para as notas citadas). No menu Ações da conversa ficam Copiar conversa, Salvar conversa como nota… (grava um .md na pasta consultada), Refazer última resposta e Editar última pergunta.

Anexar um arquivo. Quando a busca não acha o que você tinha em mente, use o botão + para anexar um arquivo: ele entra sempre na pergunta, fora da disputa da busca. Vale nota, código, texto e PDF (o texto do PDF é extraído); um binário é recusado na hora, em vez de virar lixo no contexto. O anexo aparece como uma pílula (clique para desanexar) e some ao começar uma conversa nova. Nos provedores que suportam, a resposta também vai aparecendo aos poucos, à medida que o modelo escreve.

Testar API HTTP (.lnh)

Ferramentas → Novo teste de API (.lnh)… abre um cliente HTTP gravável num arquivo .lnh. Um arquivo representa um endpoint (método, URL, cabeçalhos e corpo) e guarda vários testes na lista à esquerda — cada teste com seus valores para as variáveis {nome} usadas na URL, nos cabeçalhos e no corpo, além do resultado da última execução (status, tempo, data, cabeçalhos e corpo da resposta). Mostra também o comando curl equivalente. A mesma operação pontual está disponível por CLI (http) e MCP (http_request).

Ctrl+Enter envia a requisição.

Importar e exportar OpenAPI. O botão de setas no topo da lista de testes abre Importar OpenAPI… e Exportar OpenAPI…. A importação lê uma especificação em YAML ou JSON nas três gerações em uso — Swagger 2.0, OpenAPI 3.0 e 3.1 — e monta o teste sozinha: os {parâmetros} do caminho já são a mesma sintaxe das variáveis {nome} do .lnh, os exemplos declarados viram os valores do teste, o esquema de segurança vira o cabeçalho Authorization e cada servidor declarado vira um teste próprio (homologação e produção lado a lado). Como um .lnh guarda um endpoint, uma especificação com várias operações pergunta qual importar — ou grava todas de uma vez, um arquivo .lnh por operação.

A exportação faz o caminho inverso e gera uma especificação OpenAPI 3.0.3 a partir do arquivo: servidores, parâmetros e corpo saem do template, e as respostas de exemplo saem das execuções registradas. É um esqueleto, não um contrato completo — o .lnh descreve chamadas, então tipos, descrições e esquemas não são reconstruídos. Os seus testes viajam no campo x-lightnote-tests, e por isso voltam intactos ao reimportar o arquivo.

Importar um comando curl. No mesmo botão, Importar comando curl… abre uma caixa para colar — é de lá que o comando vem, não do disco, e o campo já vem preenchido quando há um curl na área de transferência. Entende os três dialetos em que o mesmo comando circula: o do Copiar como cURL do Chrome/Firefox (aspas simples), o do Copy as cURL (cmd) no Windows (com ^) e o exemplo de documentação quebrado com \. O método sai do -X — ou é deduzido: POST quando há corpo, GET quando não há.

A importação é literal: nenhum valor vira variável {nome} sozinho, porque adivinhar qual token é segredo erraria. Alguns casos avisam em vez de mentir — corpo vindo de arquivo (-d @arquivo) não pode ser lido, e envio multipart (-F) não é reproduzido fielmente, então os campos vão para o corpo em texto para você ajustar.

Banco de dados (.lnc)

Uma conexão é um arquivo .lnc (LightNote Connection) no próprio espaço de trabalho — versionável no Git e portável entre máquinas. Crie por Novo → Nova conexão (ou abra um .lnc existente): isso abre a visão de Banco de Dados, com a barra de status da conexão (Conectar / Desconectar / Reconectar / Editar), a árvore de Esquema (esquemas → tabelas → colunas, carregada sob demanda) e abas .sql internas. Os arquivos .sql abertos e os recentes ficam guardados dentro do .lnc, então a visão reabre no estado anterior. Se não havia nada aberto, ela começa com uma consulta vazia (sem título) onde você já pode digitar SQL; ao salvar (Ctrl+S) o LightNote pede apenas um nome e grava o arquivo dentro da pasta do projeto (sem diálogo de "salvar em qualquer lugar"). O botão + Aba abre uma nova consulta vazia, deixa abrir um arquivo (o seletor abre na pasta do projeto) ou escolher um recente / qualquer .sql da pasta do projeto.

Um .sql aberto direto pela árvore é só código (realce SQL, sem conexão).

Drivers: SQLite e DuckDB (arquivo) nativos; PostgreSQL, MySQL/MariaDB, SQL Server e genérico via ODBC; Oracle nativo (sem ODBC). O SQL Server usa o driver msodbcsql da Microsoft (instale-o na máquina) e oferece Autenticação do Windows ou usuário/senha, além das opções de criptografia do canal (Encrypt / confiar no certificado). Para o Oracle, informe a pasta do Oracle Instant Client em Configurações gerais → Banco de dados — ele é carregado em tempo de execução, sem precisar instalar nada. A conexão Oracle tem quatro modos: Service Name (host/porta/serviço), SID (host/porta/SID), Nome TNS (alias do tnsnames.ora na pasta do client) e Descritor TNS completo (colado num campo de texto).

Senha: marque Armazenar senha para cifrá-la dentro do próprio .lnc (cripto portável, abre em outra máquina); desmarcado, a senha não é guardada e é perguntada a cada conexão. A cifragem usa uma Frase-Segura por espaço de trabalho, definida em Ajuda → Configurar Frase-Segura; guarde-a, pois sem ela a senha não pode ser aberta em outro lugar. A Frase fica em cache só na máquina local (nunca vai para o Git).

Marque Conectar ao abrir para que a conexão se abra automaticamente ao abrir o .lnc. A conexão automática é silenciosa: se a senha precisar ser digitada (modo perguntar, ou cifrada sem a Frase-Segura em cache na máquina), o arquivo abre desconectado, sem interromper.

Executar: Ctrl+Enter roda a instrução sob o cursor e Alt+X roda o script inteiro; os resultados aparecem paginados, cada um numa aba Resultado com uma barra de ações no rodapé: Buscar próximo bloco ou todas as linhas, Count total, trocar o Limite de linhas, Atualizar (re-executa), Ver/Copiar SQL, Exportar... e Gerar SQL a partir da linha selecionada. Um NULL é mostrado em itálico esmaecido, distinto de um texto vazio, e os números ficam alinhados à direita; ao selecionar várias células, o rodapé mostra a contagem da seleção e, quando são numéricas, a soma e a média.

Grade de resultados: um NULL aparece em itálico esmaecido, distinto de um texto vazio, e os números ficam alinhados à direita; ao selecionar várias células, o rodapé mostra a contagem da seleção e, quando são numéricas, a soma e a média. O botão Painel de valor na barra do rodapé (ou Ver valor no painel no menu de contexto) abre um painel lateral com o valor completo da célula selecionada, sem corte, com um botão Formatar que embeleza JSON/XML só na exibição. No menu de contexto de uma célula, Filtrar por este valor / Excluir este valor reexecutam a consulta com um WHERE pela célula, e Ir para o registro referenciado segue a chave estrangeira da coluna e consulta a tabela-pai pelo valor da célula.

Plano de execução: o botão Plano de execução na barra de ferramentas mostra o EXPLAIN da instrução sob o cursor (SQLite, DuckDB, PostgreSQL e MySQL); nos bancos que não expõem o plano numa única instrução (SQL Server, Oracle) o botão fica desabilitado, com o motivo na dica.

Propriedades do objeto: dê um duplo clique numa tabela na árvore (ou F4, ou Propriedades no menu de contexto) para abrir uma aba com a estrutura do objeto, em quatro sub-abas: Colunas (nº, nome, tipo, se aceita nulo, valor padrão e um ícone de chave nas colunas da chave primária), Chaves (chaves primárias, estrangeiras, únicas e checks; um duplo clique numa chave estrangeira abre a tabela referenciada), Índices e DDL — o CREATE TABLE do objeto, para copiar, salvar como .sql ou abrir numa aba editável. Quando o banco não fornece o DDL pronto (PostgreSQL e SQL Server não têm esse comando) — ou quando o comando de DDL é negado por falta de permissão —, o LightNote o reconstrói a partir dos metadados e diz isso claramente na aba. Se nem o catálogo de colunas puder ser lido (sem permissão ou catálogo indisponível), não há do que reconstruir: a aba avisa em vez de ficar silenciosamente vazia. O menu de contexto da tabela também traz Copiar DDL sem abrir a aba.

Árvore de esquema: a árvore de Esquema separa Tabelas de Views (cada uma com seu ícone) e marca com um ícone de chave as colunas que fazem parte da chave primária. A caixa de filtro peneira entre os objetos já carregados (o carregamento sob demanda não é forçado só para filtrar).

Explorar o esquema: clique com o botão direito numa tabela para Propriedades, Copiar DDL, Inserir SELECT no editor, Visualizar dados, Contar linhas, Copiar nome qualificado ou abrir o submenu Gerar SQL → INSERT/UPDATE/MERGE: uma tela lista as colunas da tabela para você marcar Incluir e Chave, mostra um preview ao vivo e joga o comando no editor (o MERGE sai em ANSI; se o driver não suportar, um aviso aparece). Direto na grade de resultados, o botão Gerar SQL do rodapé cria INSERT/UPDATE/DELETE já preenchido com os valores da linha selecionada (disponível quando a consulta é um SELECT de uma única tabela). Os nomes de tabelas e colunas que você navega na árvore também passam a aparecer no autocomplete (Ctrl+Espaço) dos editores .sql da conexão, sem consultas extras ao banco.

Exportar resultado: clique com o botão direito na grade de resultados e escolha Exportar resultado... para gravar em CSV (delimitador, caractere de quote, quotar sempre, linha de cabeçalho, texto para NULL), JSON Lines ou SQL (comandos INSERT com nome de tabela), com limite de linhas opcional. A exportação percorre a consulta inteira em streaming (re-busca paginada), não só o que está visível na tela.

Variáveis de script: use @set nome = valor numa linha do script para definir uma variável — o prefixo @ a mantém fora do banco (não colide com o SET real de Postgres/DuckDB/SQL Server). Referências :nome são substituídas antes de executar (fora de strings e comentários; o cast ::tipo e binds como :1 ficam intactos); um :nome sem valor abre um prompt antes de rodar. O botão Variáveis na barra de ferramentas abre a tela das variáveis já definidas (editar/adicionar/remover).

Histórico de consultas: o botão Histórico abre uma janela com as últimas instruções executadas com sucesso nesta conexão, em colunas SQL / Quando / Duração / Linhas. Selecione uma para Re-executar, Inserir no editor ou Copiar (duplo-clique insere), ou use Limpar histórico. Ele fica guardado só na máquina local (não vai para o Git nem para o .lnc).

Transações: o botão Autocommit (ligado por padrão) e os botões Commit/Rollback ficam na barra de ferramentas. Com o autocommit desligado, as alterações ficam pendentes até você confirmar (Commit) ou descartar (Rollback); desconectar com uma transação aberta pergunta o que fazer.

Conexão SSH (.lns)

Uma conexão SSH é um arquivo .lns no espaço de trabalho — versionável e portável, como o .lnc. Crie por Novo → Nova conexão SSH: a aba abre um terminal SSH integrado (via ssh.exe do Windows) e uma mini-barra de arquivos remotos (SFTP).

O navegador de arquivos mostra uma pasta por vez (estilo MobaXterm/WinSCP): a primeira linha é sempre .. para subir um nível, e um duplo-clique numa pasta entra nela. A barra de caminho no topo aceita digitar um caminho remoto e Enter para ir direto. O botão Sincronizar com o terminal faz a pasta exibida acompanhar o diretório atual da sessão SSH (o que você navegou com cd no terminal). O menu de contexto (botão direito) traz Abrir no editor (baixa o arquivo, abre numa aba e reenvia ao salvar), Baixar, Enviar, Nova pasta, Renomear, Excluir e Permissões (chmod). Você também pode arrastar arquivos do Explorer para o painel para enviá-los à pasta atual.

A senha pode ser cifrada dentro do .lns com a Frase-Segura do espaço de trabalho ou perguntada a cada conexão. Chaves SSH do agente/perfil do Windows funcionam normalmente, pois a conexão usa o cliente OpenSSH do sistema.

A opção Conectar ao abrir (no diálogo da conexão) inicia a sessão SSH automaticamente ao abrir o .lns. Se a senha não estiver guardada, o próprio terminal a pede ao conectar.

Segurança: Frase-Segura, PIN e Markdown Seguro

A Frase-Segura é definida por espaço de trabalho em Ajuda → Configurar Frase-Segura… e é a chave de tudo que o LightNote cifra: senhas de conexões (.lnc/.lns), células de senha da Tabela personalizada e os arquivos .lne. A criptografia é forte e portável (Argon2id + XChaCha20-Poly1305): o arquivo cifrado abre em outra máquina, bastando recadastrar a mesma Frase lá. Guarde-a bem: sem ela, os dados cifrados não podem ser recuperados. A Frase fica em cache só na máquina local (nunca vai para o Git).

Para trocar a Frase-Segura, abra a mesma tela e edite o campo da Frase (que vem preenchido com a atual). Ao confirmar, o LightNote recifra automaticamente todos os dados seguros do espaço — senhas de .lnc/.lns, o conteúdo dos .lne e as células de senha das Tabelas personalizadas (.lnd) — da Frase antiga para a nova. A decifragem é tudo ou nada: se um único item falhar ao decifrar, nada é alterado e o LightNote avisa qual foi. Na gravação, cada arquivo é copiado para um backup antes de ser regravado; se algum falhar ao gravar, o LightNote pergunta se você quer desfazer tudo (restaura os backups) ou ignorar esse arquivo e continuar (ele fica com a Frase antiga, com aviso ao final). (Senhas em modo "perguntar" não têm o que recifrar.)

O PIN (4–8 dígitos) é um cadeado local opcional: ele protege ações sensíveis na interface (revelar senhas, abrir notas seguras) sem digitar a Frase toda hora. Ele não cifra nada e vale só nesta máquina.

O Arquivo Markdown Seguro (.lne, em Novo → Arquivo Markdown Seguro) é uma nota cifrada no disco: ao abrir, o LightNote pede o PIN (se houver) e a Frase, decifra só em memória e re-cifra ao salvar (Ctrl+S). Por segurança, ele nunca reabre sozinho ao restaurar a sessão.

Notas diárias, captura rápida e bandeja

A nota de hoje é um .md por dia na pasta Notas Diárias — uma pasta só, válida para todo o LightNote, definida em Configurações → Notas e escrita. Pelo menu da bandeja: Nota de hoje abre a nota do dia; Captura rápida… (Ctrl+Alt+N, atalho global do Windows — ou clique do meio no ícone da bandeja) abre uma janelinha onde você digita e dá Ctrl+Enter: o texto vira um item com hora na nota de hoje, gravado direto no disco, sem abrir janela do editor.

O menu da bandeja também lista as janelas abertas e os espaços recentes, e traz os toggles de energia: Manter computador acordado e Manter tela ligada (úteis em tarefas longas; o LightNote já segura a energia sozinho enquanto roda IA one-shot, células de Blocos ou script SQL). O launcher (janela de abertura) tem busca, dois cliques para abrir, e menu de contexto para fixar no topo, abrir no Explorer ou remover da lista.

As ações que valem para todo o LightNote — e não só para a janela em que você está — moram no menu Geral (☰ Geral, ou o botão com o ícone do app na barra de atividades), que tem exatamente a mesma forma do menu da bandeja: na raiz Nota de hoje, Captura rápida e Calendário; depois os submenus Capturar (tarefa rápida, gravar áudio, reencontrar notas antigas, notas adesivas), Abrir (launcher, abrir espaço de trabalho, abrir arquivo avulso, arquivos avulsos) e Energia; no fim, Configurações gerais. A regra é simples: o que está no menu da bandeja está no menu Geral — e só lá. Passar o mouse por um item mostra o aviso “recurso geral: vale para todo o LightNote, em qualquer janela”.

Para onde vai a captura. As notas diárias e as tarefas rápidas têm um destino único e previsível: a pasta definida em Configurações → Notas e escrita e o quadro definido em Configurações → Geral, valendo em qualquer janela. Na primeira captura, se nada estiver definido, o LightNote pergunta onde guardar e já grava a escolha — em vez de mandar você procurar a configuração. Um projeto que precise do próprio diário (um cliente com confidencialidade, um registro que deve morar no repositório) pode reivindicar as capturas feitas naquela janela em Configuração do Espaço de Trabalho → Capturas; a bandeja e os atalhos globais continuam gravando no destino geral. O aviso de confirmação sempre diz para onde o texto foi.

O menu da bandeja fica curto de propósito: na raiz ficam as janelas abertas e as três ações diárias — Nota de hoje, Captura rápida e Calendário. O resto vive nos mesmos submenus do menu Geral: Capturar, Abrir (que na bandeja traz também a lista de espaços recentes), IA (sessões de IA e perguntar às notas — na janela isso é o menu IA completo) e Energia. No fim, configurações e sair.

Reencontrar notas antigas

O que mais faz um "segundo cérebro" fracassar não é falta de recurso — é a nota que nunca é relida. Pelo menu da bandeja (seção Capturar), o LightNote traz notas antigas de volta à tona: Nota aleatória abre uma nota .md sorteada do espaço de trabalho (evitando as que já apareceram nas últimas duas semanas), e Neste dia lista as notas cujo aniversário de criação é hoje (mesmo dia e mês, em anos anteriores). As duas ações também estão no menu Geral → Capturar da janela.

A data de criação vem do campo created/date do frontmatter, se houver; senão, da data do arquivo. O recurso nunca escreve nas suas notas — só as abre. Pode ser desligado em Configurações → Recursos (“Reencontrar notas antigas”).

Suas notas no celular

O seu espaço de trabalho é Markdown puro numa pasta — formatos abertos, sem banco proprietário nem nuvem obrigatória. Por isso qualquer app de celular lê e edita as suas notas, sem o LightNote precisar de um aplicativo próprio para o telefone: basta sincronizar a pasta com um serviço de arquivos e abri-la num editor de Markdown no celular.

Passo a passo: sincronize a pasta do espaço de trabalho com OneDrive, Google Drive, Dropbox ou Syncthing e, no celular, abra essa pasta num editor de Markdown (por exemplo Obsidian Mobile, iA Writer, GitJournal ou Markor). Como tudo é .md em texto, os dois lados veem e escrevem as mesmas notas.

Recomendações: no celular, edite apenas arquivos .md — os tipos próprios do LightNote (.lne seguro, .lnc, .lnt, .lnb, .lnd…) não abrem fora do aplicativo, e o .lne em especial é cifrado. Se os dois lados editarem sem conexão e houver conflito, resolva pela pasta Inbox: jogue a captura (texto, áudio ou foto) lá e deixe o LightNote integrá-la à nota do dia, em vez de sobrescrever. O posicionamento é deliberado — a sincronização é por arquivos/Git, não por plugins: você é dono dos seus dados e escolhe o transporte. Para escrever direto na nota de hoje, edite o arquivo Notas Diárias/aaaa-mm-dd.md — o nome da pasta muda conforme o idioma.

Gravar áudio (voz, reunião) com transcrição por IA

Pelo menu da bandeja, Gravar áudio… abre uma janela flutuante e arrastável (arraste pela barra de título) para gravar do microfone, do áudio do sistema (o que toca no computador) ou de ambos ao mesmo tempo — a fonte escolhida é lembrada para a próxima vez. Use ● Gravar, ‖ Pausar e ■ Parar; o arquivo vai para a pasta Gravações do espaço de trabalho, comprimido para .m4a ao parar.

Dois jeitos de transcrever. Em Configurações → Assistentes de IA → Transcrição de áudio, o seletor Como transcrever escolhe entre o modelo de transcrição dedicado (estilo Whisper: OpenAI whisper-1, Groq whisper-large-v3 — grátis — ou um Whisper local) e o modelo geral com áudio no chat — o áudio vai dentro da conversa de um modelo multimodal, que é como o Google Gemini (gemini-2.0-flash, bom plano gratuito) transcreve. Trocar o provedor pré-seleciona o modo certo e sugere o modelo; áudios longos são fatiados automaticamente em qualquer modo. O modelo sugerido pode ser trocado à mão — o LightNote respeita o id que você digitar, mesmo para um provedor que ele ainda não reconheça.

Ao começar a gravar, a janela recolhe sozinha numa pílula compacta (bolinha vermelha piscando, cronômetro, Pausar/Parar) — fácil de arrastar para um canto e quase esconder durante uma reunião longa; o botão de minimizar/expandir no título alterna manualmente, e parar a gravação expande de volta. Ctrl+Alt+R (atalho global) é a nota rápida de voz: aperte para começar a gravar do microfone na hora, aperte de novo para parar, sem precisar abrir a janela pelo mouse.

Se houver um provedor de IA por API configurado (em Configurações → Assistentes de IA → Transcrição de áudio), aparecem os botões Transcrever e Transcrever + Resumir ao parar (desabilitados enquanto o áudio ainda está sendo comprimido); o combo Ao parar dispara a transcrição sozinha assim que a gravação termina. O LightNote envia o áudio para transcrição (modelo estilo Whisper) e grava uma nota .md ao lado do áudio com o texto e, opcionalmente, um resumo. Ligue/desligue o recurso em Configurações → Geral → Recursos.

A mesma janela é um mini-player: abaixo dos controles, uma lista das gravações da pasta mostra cada arquivo com botões T (abrir a transcrição) e R (abrir o resumo) quando já existem, além de um ▶ para reproduzir ali mesmo (barra de progresso com avanço); o menu ⋮ de cada linha reproduz, (re)transcreve ou abre a nota. Regerar uma transcrição não sobrescreve a anterior — cria uma nova versão ao lado (nota.md, nota (2).md…), preservando o histórico. A fonte de captura é um botão-menu (Microfone / Áudio do sistema / Ambos), com Ambos como padrão. O link Abrir pasta de gravações abre a pasta na janela principal.

Notas autoadesivas

As notas autoadesivas são caixinhas coloridas de texto puro que flutuam sobre a área de trabalho, no estilo do app Notas Autoadesivas do Windows. Pelo menu da bandeja: Nova nota adesiva (Ctrl+Alt+S, atalho global) cria uma caixinha; Mostrar notas adesivas (Ctrl+Alt+H) exibe ou oculta todas de uma vez. Cada nota tem um + para criar outra e um menu ☰ para trocar a cor, Enviar para a nota do dia (grava o texto como item na nota de hoje e descarta a caixinha) ou Excluir. Arraste pelo cabeçalho para mover e pela alça do canto para redimensionar. As notas são salvas automaticamente e reaparecem ao reabrir o LightNote.

Calendário

Geral → Calendário… abre uma janela única com um calendário que marca os dias com tarefas de todos os quadros .lnt dos espaços de trabalho registrados. Ao lado, a lista Do dia (tarefas do dia selecionado) e as Pendências; o botão Nota do dia abre a nota diária da data. Clicar numa tarefa abre o quadro correspondente.

Na grade, cada dia com tarefa recebe pontos coloridos na cor do status do Kanban (até três), o dia de hoje é marcado por um anel e o dia selecionado por um círculo cheio; Hoje volta ao mês corrente e o nome do mês abre um menu para saltar de mês ou de ano. As Pendências vêm agrupadas por situação — Atrasadas, Hoje, Próximos 7 dias, Depois e Sem data —, com o vencimento num selo relativo (“ontem”, “hoje”, “há 3 dias”). Um duplo clique num dia abre a tarefa rápida já com aquela data.

Paleta de comandos

Ctrl+Shift+P abre a paleta de comandos (todas as ações com seus atalhos, filtráveis por digitação). Ctrl+P abre o seletor rápido de arquivos e Ctrl+Shift+K abre o seletor de tarefas.

Servidor MCP (agentes de IA)

O LightNote inclui um servidor MCP (Model Context Protocol) headless que transforma o seu espaço de trabalho numa ferramenta para agentes de IA (Claude Desktop, Claude Code, Cursor, e qualquer cliente que fale MCP). Com ele, o agente lê e escreve arquivos, faz buscas, consulta dados tabulares e bancos, manipula as tarefas, usa o Git e dispara requisições HTTP — tudo confinado à pasta (directory jail: caminhos com .. ou fora da raiz são recusados). O transporte é JSON-RPC 2.0 por stdin/stdout; cada sessão sobe um processo lnote.exe leve, separado da janela do editor.

Atalho de um clique: em IA → Ativar IA nesta pasta o LightNote habilita o MCP e escreve o .mcp.json de uma vez (o clique já é o consentimento). Se a IA já estiver ativa na pasta, o item vira Configurar IA desta pasta… e abre a Configuração do Espaço de Trabalho.

Segurança em duas camadas: (1) o servidor só inicia se você tiver dado opt-in naquela pasta; (2) toda ferramenta fica presa à raiz do espaço. Além disso, cada ferramenta é anunciada com anotações (somente-leitura, destrutiva, idempotente, "toca o mundo externo") para o cliente de IA avaliar o risco antes de chamar.

Passo a passo para configurar

  1. Habilite o MCP na pasta. Em Ferramentas → Configuração do Espaço de Trabalho, marque Habilitar MCP para este espaço. Sem esse opt-in o servidor recusa iniciar (é a trava principal). Como alternativa, pela linha de comando: lnote --mcp-enable "C:\Caminho\do\espaco" (e --mcp-disable para desligar).
  2. Descubra o caminho do lnote.exe. Ele fica na mesma pasta do lightnote.exe (a pasta de instalação do aplicativo). É o executável de console "slim", sem interface — é ele que o agente executa.
  3. Registre o servidor no seu cliente de IA, apontando o comando para o lnote.exe e passando --mcp seguido da pasta do espaço. No formato usado por Claude Desktop / Cursor e semelhantes:
{
  "mcpServers": {
    "lightnote": {
      "command": "C:\\Caminho\\para\\lnote.exe",
      "args": ["--mcp", "C:\\Caminho\\do\\espaco"]
    }
  }
}

Dicas de configuração:

  • Barras invertidas em JSON precisam ser duplicadas (C:\\Users\\...\\lnote.exe), como no exemplo.
  • Para expor vários espaços, crie uma entrada por pasta, com nomes distintos ("lightnote-projetoA", "lightnote-projetoB"), cada uma apontando para a sua raiz.
  • Depois de salvar a configuração, reinicie o cliente de IA para ele subir o servidor. Ao conectar, o agente deve listar as ferramentas lightnote_*; peça a ele um "liste os arquivos do espaço" para confirmar que está funcionando.
  • Para o Claude Code (CLI), o mesmo servidor pode ser registrado com claude mcp add lightnote -- "C:\Caminho\para\lnote.exe" --mcp "C:\Caminho\do\espaco".

Senha de banco (opcional). A ferramenta db_query abre uma conexão .lnc. Se a senha estiver cifrada com a Frase-Segura, passe a frase pela variável de ambiente LNOTE_PASSPHRASE no bloco do servidor (nunca em argumentos de linha de comando) — conexões com senha em modo "perguntar" não podem ser usadas de forma desatendida.

Consulta por IA é opt-in por conexão. Ligar o MCP na pasta não expõe as conexões: cada .lnc só responde ao db_query quando a opção «Permitir consultas por IA (MCP)» está marcada no diálogo da conexão. O acesso é somente-leitura (SELECT).

Exportar do banco pelo agente. Alem de consultar, o agente pode materializar um SELECT num arquivo com db_export (Parquet, CSV, JSON ou .xlsx) — util para resultados grandes demais para caber na resposta. Valem os mesmos tres cuidados, nesta ordem: a consulta precisa ser somente-leitura, a conexao precisa do opt-in «Permitir consultas por IA (MCP)» (verificado antes de decifrar a senha) e o destino precisa ficar dentro do espaco de trabalho. Exportacoes grandes usam a pasta temporaria do sistema como area de apoio, em torno do tamanho do resultado — deixe espaco livre em disco.

Ferramentas disponíveis

O agente enxerga as ferramentas pelo prefixo do cliente (ex.: lightnote_read_file). Por categoria:

  • Arquivos: read_file (com intervalo de linhas opcional), write_file, edit_file (substitui um trecho exato, sem reescrever o arquivo inteiro), append_file, list_files, move_file, make_dir e delete_file (vai para a Lixeira, não apaga de vez).
  • Busca e navegação: search_files (ripgrep, com filtro por subpasta/glob e limite), list_symbols (outline de funções/classes de um arquivo) e open_in_editor (abre/foca um arquivo na janela do LightNote, se estiver aberta).
  • Dados e SQL: query (SQL DuckDB sobre Parquet/CSV/JSON, saída em tsv/json/markdown), describe_table (esquema + estatísticas, sem despejar linhas), export_query (materializa um SELECT num arquivo via COPY), sqlite_query (SQL num .sqlite/.db), db_list_connections (lista os .lnc do espaço) e db_query (SQL somente-leitura numa conexão .lnc). Também: xlsx_read (lê uma planilha .xlsx como TSV, sem DuckDB), data_diff (compara dois arquivos tabulares — linhas só em A/só em B, alteradas por chave, ou deriva do esquema), e o catálogo de banco db_list_objects (tabelas/views) e db_describe (colunas, chaves e o CREATE — nativo ou reconstruído) — estes dois com os mesmos requisitos do db_query (opt-in por conexão + LNOTE_PASSPHRASE). Para levar o resultado para um arquivo em vez da resposta, db_export (Parquet/CSV/JSON/.xlsx).
  • Além disso: search_notes (recupera os trechos mais relevantes das notas para uma pergunta — o mesmo motor do Perguntar às notas), list_links (os links de saída de uma nota, resolvidos ou quebrados), audit_vault_links (links quebrados e notas órfãs em todo o vault), list_note_templates e o parâmetro template do create_note, list_due_tasks (tarefas que vencem hoje ou atrasadas em todos os projetos), xlsx_read (lê uma planilha .xlsx como TSV), data_diff (compara dois arquivos tabulares) e o catálogo do banco db_list_objects/db_describe (tabelas/views e as colunas, chaves e DDL de uma tabela — os mesmos requisitos do db_query).
  • Compactados: zip_list (lista os membros de um .zip/.isx) e zip_read (lê um membro como texto) — sem extrair o arquivo para o disco.
  • Tarefas: list_task_projects (lista os projetos de tarefa .lnt do espaço), list_tasks, list_task_statuses (colunas do quadro), create_task, update_task, update_task_status (mover de coluna), delete_task, task_note (ler/gravar a nota .md da tarefa) e list_due_tasks (tarefas vencendo hoje ou atrasadas em todos os projetos do espaço). Um espaço pode ter vários projetos .lnt: escolha qual pelo parâmetro project (o name devolvido por list_task_projects; dispensável se só houver um). Os id/status_id são identificadores da sessão — não leia os arquivos internos do .lnt para obtê-los; use as ferramentas de tarefa.
  • Notas (PKM): create_note (cria uma nota .md), append_daily_note (acrescenta uma captura à nota do dia), list_backlinks (notas que apontam para uma nota), list_note_tags e search_by_tag (as #hashtags do vault e as notas que as usam) e add_task (cria tarefa com vencimento/etiquetas, aceitando linguagem natural no título). Também: search_notes (recupera os trechos mais relevantes das notas para uma pergunta — o mesmo motor do Chat com IA), list_links (os links de saída de uma nota, resolvidos ou quebrados), audit_vault_links (links quebrados e notas órfãs de todo o vault), list_note_templates e o parâmetro template do create_note (cria a nota já a partir de um modelo).
  • Git: git_status, git_log, git_diff e git_restore.
  • Web e avisos: http_request (dispara uma requisição HTTP e devolve status/cabeçalhos/corpo) e notify (mostra um aviso na bandeja da janela aberta — útil para o agente sinalizar que terminou).
  • Proxy de IA: list_ai_models e ask_ai (abaixo).

O servidor também expõe os arquivos do espaço como recursos MCP (resources/list e resources/read), para clientes que preferem "anexar" arquivos em vez de chamar read_file.

A sua Biblioteca de prompts (a pasta Prompts/ do espaço) é exposta como prompts MCP (prompts/list e prompts/get). No Claude Code, cada prompt vira um comando de barra — /mcp__lightnote__<nome> — pronto para usar dentro da CLI de IA.

Rede de segurança das escritas. Antes de sobrescrever (write_file/edit_file) ou remover (delete_file) um arquivo, o servidor grava a versão anterior no Histórico Local — a mesma rede de segurança do editor —, para você poder desfazer uma mudança feita por um agente mesmo fora de um repositório Git.

Cada ferramenta declara se é de leitura ou escrita: além das annotations MCP (readOnlyHint/destructiveHint), a descrição começa com um selo [read-only], [writes] ou [destructive] — útil para montar listas de permissão com segurança.

Proxy de IA (delegar a outro modelo)

Os provedores de API que você cadastrou com a coluna MCP marcada ficam disponíveis ao agente por duas ferramentas: list_ai_models (lista os modelos liberados, com id, nome e modelo) e ask_ai ({model, prompt}). Assim o agente principal pode delegar uma sub-tarefa a um modelo mais barato ou especializado. A chamada é intermediada pelo LightNote aberto (o lnote.exe do MCP repassa o pedido à janela do aplicativo pela ponte interna): a chave de API nunca sai da sua máquina e nunca chega ao agente. Se o LightNote não estiver aberto, a ferramenta retorna um erro pedindo para abri-lo.

Linha de comando (lnote)

As mesmas operações do MCP estão num executável de console, lnote, para scripts e automação (também acessível como lightnote cli <comando>). Toda ação fica confinada à pasta-raiz, definida por --root (padrão: a pasta atual).

Exemplos:

lnote list --recursive
lnote read --path src/main.cpp --start-line 1 --end-line 40
lnote write --path nota.md --content "Olá"
echo conteudo | lnote write --path nota.md --content -
lnote search --query TODO --regex
lnote query --sql "SELECT * FROM read_parquet('dados.parquet') LIMIT 10"
lnote describe --path dados.parquet
lnote search-notes --query "onde escrevi sobre orçamento"
lnote audit-links
lnote xlsx-read --path planilha.xlsx --sheet 0
lnote data-diff --a antes.parquet --b depois.parquet --mode changed --keys id
lnote db-describe --connection dados.lnc --table clientes
lnote db-export --connection dados.lnc --sql "SELECT * FROM clientes" --out clientes.parquet
lnote due-tasks
lnote export --sql "SELECT * FROM read_csv_auto('e.csv') WHERE uf='SP'" --out sp.parquet
lnote zip-list --path export.isx
lnote zip-read --path export.isx --entry job/definicao.xml
lnote task-projects
lnote tasks --project Backlog
lnote create-task --project Backlog --title "Revisar texto" --effort 2
lnote move-task --project Backlog --task-id 5 --status-id 2
lnote git-status
lnote http --url https://api.exemplo.com --method GET
lnote notify --message "Processamento concluído"

Globais: --root <pasta>, --json (saída estruturada {ok,data,error}), --help (ou lnote <comando> --help) e --version. Comandos desconhecidos recebem uma sugestão ("você quis dizer…?").

Atualizar dados antigos em lote: lnote upgrade <pasta> moderniza de uma vez os arquivos gravados por versões anteriores do LightNote — hoje, as extensões legadas .lnsh e .lnsm, que passaram a ser .lns e .lne. O aplicativo já faz isso sozinho ao abrir cada arquivo; o comando existe para quem tem dezenas e não quer abrir um a um. Use --dry-run para ver o que mudaria sem tocar em nada. É conveniência, não obrigação: seus arquivos antigos continuam abrindo normalmente sem ele.

Configurações e temas

Em Ferramentas → Configurações gerais você ajusta, em seções: opções Gerais (idioma, auto-salvar, liberar abas ociosas, paleta de cores das abas, título da janela, notas diárias, ortografia), o Tema da aplicação, a fonte e as cores do Editor, o estilo do Markdown, a Execução (interpretadores), o Terminal (shells), os Assistentes de IA (CLIs e a IA padrão), o Versionamento e o Banco de Dados (paginação, Oracle Instant Client).

Há um campo de busca no topo da lista de seções que filtra pelas opções de cada página; e a seção Recursos reúne os interruptores dos recursos opcionais — Grafo de conexões, Notas autoadesivas, Sessões de IA, Chat com IA, gravação de áudio, reencontrar notas antigas, manter o computador acordado e a integração ao menu do Windows Explorer. Desligar um recurso o remove da interface, da bandeja e dos atalhos, e para de consumir recursos — mas mantém os dados já criados; a mudança vale ao reiniciar.

O tema da aplicação muda a aparência do programa (menus, abas, painéis, barra de status). Há vários temas prontos — claros (Claro, Solarized Light, Catppuccin Latte, Gruvbox Light, One Light, Rosé Pine Dawn) e escuros (Escuro, Tokyo Night, Dracula, Ayu Mirage, Nord, Gruvbox Dark) — além do modo Personalizado com cor de acento. Novos temas chegam pelo catálogo online, sem precisar atualizar o aplicativo.

As cores do Editor de código e do Markdown são escolhidas à parte, nas suas próprias seções, e independem do tema da aplicação. Cada uma traz uma combo Tema: com esquemas de cor prontos (Padrão, Dracula, One, Nord, Gruvbox e Tokyo Night, em versões clara e escura), uma prévia ao vivo e o botão Salvar como… para guardar suas próprias cores como um preset reutilizável.

Tema por janela. Cada pasta (espaço de trabalho) pode ter o seu próprio tema, então você pode manter duas janelas abertas com aparências diferentes ao mesmo tempo. Em Configuração do Espaço de Trabalho → Aparência desta pasta há combos para o tema desta janela (a aparência do programa), o tema de código e o tema de Markdown — todos com a opção Seguir tema geral/Manter padrão para não sobrepor. Sobrepor os temas de código e de Markdown é útil para casar as cores do editor com um tema escuro só naquela pasta, sem mexer nas Configurações gerais. Essas escolhas ficam só na sua máquina (não vão para o Git).

Guia de instalação. Quando você escolhe uma ferramenta do catálogo (assistente de IA, interpretador, formatador, linter ou driver de banco) que ainda não está no computador — ou tenta executar/formatar/verificar um arquivo cujo interpretador falta — o LightNote abre um guia de instalação. Quando existe um comando seguro (via winget), o guia mostra o comando exato e o executa num console embutido, com um clique; se a ferramenta depende de outra (por exemplo, uma CLI que precisa do Node.js), ele oferece instalar o pré-requisito antes. Sem um instalador automático, o guia abre a página oficial de download e traz um passo a passo. Ao terminar, ele verifica a instalação e já deixa a ferramenta pronta para uso, sem reiniciar o programa.

Formatação e Linters têm seções próprias (formatador/linter externo por linguagem, com Adicionar a partir de um catálogo). Para levar suas preferências a outra máquina, o grupo Migração de configurações (seção Geral) tem Exportar/Importar configurações (arquivo .lnconf): vão as opções gerais e os temas de conteúdo, mas não as chaves de API nem os caminhos locais (recadastre-os no destino).

O título da janela é um modelo livre: o nome do aplicativo entra sempre no fim e você compõe o resto com as variáveis {espaço} (pasta raiz do espaço de trabalho), {arquivo} (nome do arquivo aberto) e {caminho} (caminho completo). Decorações ao redor de uma variável vazia (ex.: os colchetes em [ {espaço} ]) somem sozinhas; deixe o campo em branco para o padrão [ {espaço} ] {arquivo} — .

Layout da janela. Em Exibir → Layout da janela (ou em Configurações gerais → Geral → Layout da janela) você escolhe entre três presets — Moderno (o padrão), Clássico e Confortável — ou ajusta cada opção separadamente: exibir a barra de menus no topo (com ela ligada o botão ☰ some, pois os dois abrem os mesmos menus), mostrar rótulos ao lado dos ícones, pôr a barra de ferramentas e a barra lateral à esquerda ou à direita, e o tamanho dos ícones. Escolher um preset apenas preenche as opções: mexer em qualquer uma delas depois não desfaz nada, a lista só passa a exibir "(personalizado)". A mudança vale na hora, em todas as janelas abertas.

Atalhos de teclado

  • F1 — esta ajuda (na seção da tela atual)
  • Ctrl+N / Ctrl+O — novo arquivo / abrir arquivo
  • Ctrl+S / Ctrl+W — salvar / fechar aba
  • Ctrl+Alt+Shift+S — salvar tudo (todas as abas modificadas)
  • Ctrl+F / Ctrl+H — localizar / substituir no arquivo
  • Ctrl+Shift+F — busca global (ripgrep)
  • Ctrl+Shift+G — painel de versionamento (Git)
  • Ctrl+Shift+E / Ctrl+Shift+M — painel Explorador / painel de Pendências
  • Ctrl+B — mostrar/ocultar a barra lateral
  • Ctrl+' — terminal (no layout US, também Ctrl+`)
  • Ctrl+/ — comentar/descomentar; Ctrl+Shift+D — duplicar linha
  • F5 — executar arquivo; Ctrl+Shift+Enter — enviar seleção ao terminal
  • Ctrl+K / Ctrl+I — perguntar à IA / editar com IA
  • Ctrl+B / Ctrl+I / Ctrl+E — na nota Markdown: negrito / itálico / alternar o modo de exibição
  • Ctrl+Enter — “executar aqui”: instrução SQL, célula de Blocos, requisição de API
  • Ctrl+Shift+R / F4 — macro: gravar / reproduzir
  • Ctrl+P — ir para arquivo; Ctrl+Shift+P — paleta de comandos
  • Ctrl+Shift+K — ir para tarefa; Ctrl+Shift+T — reabrir aba fechada
  • Ctrl+Alt+G — grafo de conexões
  • Ctrl+Alt+N — captura rápida (global, mesmo fora do LightNote)
  • Ctrl+Alt+D / Ctrl+Alt+T — nota de hoje / tarefa rápida
  • Ctrl+Alt+R — gravar/parar áudio (global, nota rápida de voz)
  • F11 — modo Zen (a aba ocupa a janela inteira)
  • Ctrl++ / Ctrl+- / Ctrl+0 — zoom

A lista completa, com filtro, fica em Ajuda → Atalhos de teclado.

Licença, edições e comunidade

O LightNote é distribuído em edições com os mesmos recursos, diferindo apenas no licenciamento e na forma de entrega:

  • LightNote (grátis, pelo site): para uso pessoal e não comercial.
  • LightNote Core (Microsoft Store): adquirida como uma contribuição ao projeto; concede licença de uso comercial e recebe atualizações automáticas pela Store.
  • LightNote Business (futuro): licenciamento por volume/corporativo, reservado para disponibilização futura.

A edição da sua cópia — e, portanto, quais cláusulas valem — aparece em Ajuda → Sobre. O texto completo dos termos está em Ajuda → Sobre → Termos de licença….

Participe e contribua:

  • Sugestões e dúvidas: GitHub Discussions — github.com/nglczr/LightNote-Community/discussions
  • Encontrou um bug? Relate em GitHub Issues — github.com/nglczr/LightNote-Community/issues
  • Apoie o desenvolvimento no Ko-fi — ko-fi.com/lightnote (ou adquira o LightNote Core na Store)
  • Contato: contato@lightnote.com.br · Site: lightnote.com.br