Manual do EEditor

1. Primeiros Passos

Ao iniciar o EEditor pela primeira vez, você vê um editor vazio com uma barra lateral. Três passos para começar:

1. Abrir uma pasta — pressione ⌘O ou toque no ícone de pasta. O EEditor escaneia o diretório e exibe todos os arquivos na árvore da barra lateral.
2. Selecionar um arquivo — clique em qualquer arquivo na barra lateral para abri-lo em uma nova aba.
3. Comece a escrever — as edições são salvas automaticamente após 1 segundo de inatividade. Pressione ⌘S para salvar imediatamente.

Abrindo arquivos individuais

Use ⌘⇧O para abrir um único arquivo de qualquer lugar no disco. O diretório pai do arquivo se torna a pasta ativa.

2. O Editor

O EEditor oferece um ambiente de escrita sem distrações com destaque de sintaxe em tempo real para Markdown e mais de 24 linguagens de programação.

• Destaque de sintaxe — títulos, negrito, itálico, blocos de código, links e mais são coloridos para Markdown. Arquivos de código recebem destaque de palavras-chave, tipos, strings, números e comentários.
• Buscar e Substituir (⌘F) — pesquise dentro do documento atual, substitua uma ou todas as ocorrências.
• Inserir data/hora (⌘I) — insere YYYY-MM-DD HH:mm na posição do cursor.
• Desfazer / Refazer — ⌘Z / ⌘⇧Z.
• Indicador de linguagem — a linguagem detectada é exibida no canto inferior direito.
• Wiki-links — posicione o cursor em [[nome-do-arquivo]] e pressione ⌘O para abrir o arquivo.
• Enviar para o REPL (⌘R) — selecione texto no editor e pressione ⌘R para preencher o campo de entrada do REPL. Pressione Enter para avaliar.

3. Barra Lateral e Árvore de Arquivos

A barra lateral mostra uma visualização hierárquica da sua pasta. Diretórios aparecem primeiro, depois arquivos em ordem alfabética.

• Expandir/recolher pastas — clique no triângulo de expansão.
• Criar um novo arquivo (⌘N) — digite um nome como subpasta/arquivo.md para criar arquivos aninhados.
• Criar uma nova pasta — use o botão pasta + na barra de ferramentas.
• Excluir — clique com botão direito → Excluir (movido para a Lixeira no macOS).
• Renomear — clique com botão direito → Renomear.
• Atualizar (⌘⇧R) — reescaneia o diretório preservando o estado de expansão.
• Executar no REPL — clique com botão direito em um arquivo .el ou .lisp para executá-lo.
• Revelar no Finder (macOS) — clique com botão direito para mostrar no Finder.
• Indicador de alterações — um ponto aparece ao lado de arquivos com alterações não salvas.

A barra lateral possui três modos através do controle segmentado: Arquivos, Calendário e Agenda.

4. Abas e Arquivos Fixados

Cada arquivo abre como uma aba no topo do editor.

Abas fixadas exibem um ícone de pino, aparecem primeiro (ordenadas alfabeticamente) e não podem ser fechadas até serem desfixadas. Elas são restauradas automaticamente ao reiniciar.

5. Busca e Abertura Rápida

Busca em texto completo (⌘⇧F)

• Pesquisa em todos os arquivos do workspace.
• Resultados agrupados por arquivo com números de linha e contexto.
• Alterne o modo sensível a maiúsculas/minúsculas com o botão Aa.
• Clique em um resultado para abrir o arquivo naquela posição.

Abertura Rápida (⌘P)

• Correspondência fuzzy de nomes de arquivo — os resultados atualizam conforme você digita.
• Teclas de seta para navegar, Enter para abrir, Escape para cancelar.
• Correspondências de prefixo têm prioridade; nomes mais curtos desempatam.
• Pré-preenchimento da seleção: se houver texto selecionado no editor, ⌘P preenche a busca automaticamente.

Wiki-links (⌘O)

Posicione o cursor em um link [[nome-do-arquivo]] e pressione ⌘O para abrir o arquivo diretamente.

6. Visualização e Exportação PDF

Visualização Markdown (⌘⇧P)

• Renderiza seu documento como HTML estilizado com suporte a modo claro/escuro.
• No macOS, a visualização abre em um quadro; no iOS, aparece como uma sheet.

Exportação PDF (⌘⇧E)

• Gera um documento A4 pronto para impressão (595 × 842 pt) com tipografia limpa.
• macOS: diálogo de salvar com nome de arquivo sugerido. iOS: folha de compartilhamento.

7. Notas Diárias e Planejador Semanal

Nota diária (⌘D)

• Cria YYYY-MM-DD.md na raiz do projeto, pré-preenchido com um título de data.
• Abre o arquivo existente caso ele já exista.

Planejador semanal (⌘⇧W)

• Cria Week of YYYY-MM-DD.md (segunda-feira da semana atual).
• Pré-preenchido com um modelo estruturado: segunda a domingo, seções Manhã/Tarde/Noite.

8. Visualização de Calendário

Alterne a barra lateral para o modo Calendário usando o controle segmentado.

• Uma grade mensal mostra o mês atual (início na segunda-feira, ISO 8601).
• Indicadores de pontos duplos: ponto azul = atividade de arquivo, ponto laranja = itens da agenda.
• Navegue entre meses com os botões < / >. Hoje volta ao mês atual.
• Clique em um dia para ver os arquivos modificados naquele dia e os itens da agenda agendados para aquela data.

9. Barra Lateral de Agenda

Alterne para o modo Agenda pelo ícone de prancheta. O painel mostra sua programação em três seções:

• Atrasados — itens com uma data :when anterior a hoje.
• Hoje — itens agendados para hoje.
• Próximos 7 Dias — itens futuros dentro da semana.

Cada item mostra um ponto de prioridade (vermelho = urgente, laranja = alta, amarelo = média, cinza = normal), texto, categorias e data formatada. Toque em atualizar para recarregar após adicionar itens no REPL.

Barra Lateral do REPL

O REPL é um painel na barra lateral direita que coexiste com o editor. Alterne-o com ⌘⇧L ou o ícone de terminal na barra de ferramentas.

• Funcionalidade completa do REPL: campo de entrada, suporte a múltiplas linhas, histórico persistente, formulários inline e tabelas.
• Permanece aberto enquanto você alterna entre arquivos, abre novas abas e navega — não fecha até que você o feche explicitamente.
• O estado da barra lateral é persistido entre sessões — se estava aberto ao sair, reaparece ao reiniciar.
• Útil para cálculos rápidos, consultas de dados, gerenciamento de bancos de dados ou execução de scripts junto aos seus documentos.

Blocos de Código EELisp em Markdown

Incorpore código EELisp executável diretamente nos seus arquivos Markdown usando blocos de código delimitados:

```eelisp
(+ 1 2 3)
```

Executando um bloco de código

1. Posicione o cursor em qualquer lugar dentro de um bloco ```eelisp.
2. Pressione ⌘⇧Return (ou use o menu: Visualizar → Executar Bloco EELisp).
3. O resultado aparece como um bloco ```result logo abaixo.

```eelisp
(+ 1 2 3)
```
```result
6
```

Reexecutar substitui o resultado existente. O resultado é inserido como texto simples (não em um bloco de código) e é selecionado automaticamente para que você possa imediatamente ⌘C para copiar ou ⌘X para recortar.

Formulários e tabelas no editor

Quando um bloco EELisp retorna um formulário (edit, defform) ou tabela (browse), ele abre como um painel lateral interativo ao lado do editor em vez de inserir texto simples. Você pode interagir com o formulário — navegar registros, editar campos, salvar — mantendo seu documento visível. Uma linha de resumo ainda é inserida no documento.

Casos de uso incluem cálculos inline, adição de itens de agenda a partir de entradas de diário, consulta de dados e operações com arquivos:

```eelisp
(add-item (smart-parse "tomorrow review quarterly report !!"))
```

```eelisp
(write-file "todo.txt" "Buy groceries\nCall dentist")
```

10. Atalhos de Teclado

Pressione ⌘? no aplicativo para ver a folha completa de atalhos. Aqui está a referência completa:

Arquivos

Navegação

Abas

Edição

Visualização e Exportação

11. Usando o REPL

O EEditor inclui um interpretador Lisp embutido chamado EELisp — projetado para gerenciamento de dados pessoais, cálculos e scripts.

Abrindo o REPL

• Pressione ⌘⇧L para alternar a barra lateral do REPL, ou toque no ícone de terminal na barra de ferramentas.
• Se você tiver texto selecionado no editor, ⌘⇧L o envia para o campo de entrada do REPL automaticamente.
• O REPL abre como um painel na barra lateral direita que permanece aberto enquanto você alterna entre arquivos e abas.
• O estado da barra lateral é persistido entre sessões — se estava aberto ao sair, reaparece ao reiniciar.
• Pressione ⌘⇧L novamente ou clique no botão × no cabeçalho do REPL para fechá-lo.

Avaliando expressões

• Digite uma expressão no prompt > e pressione ⌘Return para avaliar.
• Entrada multilinha — se os parênteses estiverem desbalanceados, o prompt muda para .. e aguarda mais. Uma barra de dica mostra ⌘↩ para executar · ⎋ para cancelar.
• Histórico — pressione Seta Cima/Baixo para navegar pelos comandos anteriores. O histórico é persistido entre sessões (até 100 entradas).
• Selecionar e copiar — o texto de saída é selecionável. Clique com botão direito → Copiar Toda a Saída.

Enviar para o REPL (⌘R ou ⌘⇧L)

Selecione texto no editor e pressione ⌘R ou ⌘⇧L. A barra lateral do REPL abre com sua seleção pré-preenchida no campo de entrada, pronta para você pressionar ⌘Return para avaliar.

Comandos de banco de dados

O EELisp inclui funções embutidas e comandos do REPL para gerenciamento de bancos de dados:

Carregando arquivos

Use :load path/to/file.el para carregar e avaliar um script EELisp. No iOS, toque no botão Carregar na barra de ferramentas ou clique com botão direito em um arquivo .el na barra lateral.

Barra de ferramentas do iOS

No iOS/iPadOS, uma barra de ferramentas aparece com: navegação de histórico (↑/↓), snippets rápidos (query, deftable, defn), Carregar Arquivo e Limpar.

12. Comandos do REPL

Comandos prefixados com dois-pontos controlam o próprio REPL (não são expressões EELisp):

13. Aritmética e Matemática

Todos os operadores aritméticos são variádicos (aceitam múltiplos argumentos) e funcionam com inteiros e números de ponto flutuante.

;; Exemplos de aritmética
(+ 1 2 3 4)            ; → 10
(* 6 7)                ; → 42
(/ 100 3)              ; → 33.333...
(pow 2 10)             ; → 1024
(round 3.14159 2)     ; → 3.14

;; Aninhamento
(+ (* 3 4) (- 10 5))    ; → 17

14. Comparação e Lógica

Operadores lógicos

Estes são formas especiais (avaliação em curto-circuito):

(and true false)        ; → false
(or  false true)        ; → true
(not true)              ; → false

;; Curto-circuito: (or) retorna o primeiro valor verdadeiro
(or nil false 42 99)    ; → 42

15. Variáveis e Funções

Definindo variáveis

(def x 42)
(def greeting "Hello, world!")
(def pi 3.14159)

Definindo funções

(defn square (x)
  (* x x))

(square 5)  ; → 25

;; Corpo com múltiplas expressões (último valor é retornado)
(defn greet (name)
  (def msg (str "Hello, " name "!"))
  (println msg)
  msg)

Funções anônimas

(map (fn (x) (* x x)) '(1 2 3))  ; → (1 4 9)

Parâmetros rest

(defn sum (first . rest)
  (reduce + first rest))

(sum 1 2 3 4 5)  ; → 15

Ligações locais

(let ((x 1) (y 2))
  (+ x y))  ; → 3

16. Fluxo de Controle

if

(if (> x 0) "positive" "non-positive")

cond

(cond
  (< x 0)  "negative"
  (= x 0)  "zero"
  else     "positive")

when

;; Executa o corpo somente se a condição for verdadeira
(when (> x 0)
  (println "positive!")
  x)

loop / recur

;; Soma de 0 a 10
(loop ((i 0) (acc 0))
  (> i 10)
  (recur (+ i 1) (+ acc i)))  ; → 55

begin

;; Avalia múltiplas expressões, retorna a última
(begin
  (def a 10)
  (def b 20)
  (+ a b))  ; → 30

17. Strings

18. Listas

;; Encadeando operações de lista
(def nums (range 1 11))
(filter even? nums)            ; → (2 4 6 8 10)
(map (fn (x) (* x x))
     (filter even? nums))       ; → (4 16 36 64 100)
(reduce + 0 (range 1 101))   ; → 5050

19. Dicionários

Dicionários usam chaves de palavra-chave (:name) e são imutáveis — operações retornam novos dicionários.

(def person {:name "Alice" :age 30})
(dict-get person :name)          ; → "Alice"
(dict-set person :age 31)        ; → {:name "Alice" :age 31}
(dict-merge person {:city "NYC"}) ; → {:name "Alice" :age 30 :city "NYC"}

20. Tipos e Conversão

Predicados de tipo

Inspeção de tipo

(type 42)          ; → "number"
(type "hello")     ; → "string"
(type '(1 2))      ; → "list"

Funções de conversão

21. I/O & Datas

Saída

Funções de data

(today)                              ; → "2026-02-23"
(date-add (today) 7 :days)          ; → "2026-03-02"
(date-add "2026-01-31" 1 :months)   ; → "2026-02-28"
(date-diff "2026-01-01" "2026-12-31") ; → 364

22. Funções do Prelude

Essas funções são definidas no próprio EELisp e carregadas automaticamente na inicialização:

23. HTTP & JSON

;; Buscar dados de uma API
(def resp (http-get "https://api.example.com/data"))
(def data (json-parse (dict-get resp :body)))

;; Enviar JSON via POST
(http-post "https://api.example.com/items"
  (json-stringify {:name "test"})
  :content-type "application/json")

Avaliação

Sistema de Arquivos

O EELisp pode ler e escrever arquivos na sua pasta aberta. Todos os caminhos são relativos ao diretório do workspace atual.

;; Ler um arquivo
(def content (read-file "notes.md"))

;; Escrever resultados em um arquivo
(write-file "output.txt" (str "Report: " (today)))

;; Adicionar a um log
(append-file "log.txt" (str (today) " - Done\n"))

;; Listar arquivos do workspace
(list-files)       ; → ("README.md" "notes.md" ...)
(list-files "src") ; → ("main.el" "utils.el" ...)

Integração com o Editor

Esses builtins permitem que o código EELisp interaja com o buffer ativo do editor.

;; Inserir texto na posição do cursor
(insert-at (cursor-pos) (str "Updated: " (today)))

;; Obter o que está selecionado
(def sel (selection))

;; Ler o buffer inteiro
(def text (buffer-text))
(println (str "Length: " (str-len text)))

Área de Transferência

;; Copiar um resultado para a área de transferência
(clipboard-set (str "Total: $" (reduce + 0 '(10 20 30))))

;; Colar e processar conteúdo da área de transferência
(str-upper (clipboard-get))

24. Definindo Tabelas

O EELisp inclui um mecanismo de banco de dados SQLite integrado. As tabelas são definidas com esquemas tipados.

Sintaxe básica

(deftable contacts (name:string email:string age:number))

Tipos de campo

Gerenciamento de tabelas

;; Exemplo completo
(deftable tasks (title:string priority:number done:bool due:date))
(tables)       ; → (tasks)
(describe tasks) ; → detalhes do esquema

25. Registros & Consultas

Inserindo registros

(insert tasks {:title "Write docs" :priority 1 :done false})
(insert tasks {:title "Fix bug" :priority 2 :done false :due "2026-03-01"})

Consultando

;; Todos os registros
(query tasks)

;; Com cláusula WHERE
(query tasks :where "priority <= ?" :params (list 2))

;; Ordenado e limitado
(query tasks :order "priority" :limit 5)

;; Selecionar colunas específicas
(query tasks :select "title, done")

;; Ordem decrescente
(query tasks :order "priority" :asc false)

Atualizando & excluindo

;; Atualizar por ID
(update tasks 1 {:done true})

;; Soft-delete (estilo dBASE, pode ser recuperado)
(delete tasks 1)

;; Remover permanentemente registros com soft-delete
(pack tasks)

;; Contar registros
(count-records tasks)
(count-records tasks :where "done = ?" :params (list false))

Acesso a registros

;; Trabalhando com resultados de consulta programaticamente
(def results (query tasks :where "done = ?" :params (list false)))
(def recs (records results))
(map (fn (r) (field-get r :title)) recs)  ; → ("Write docs" "Fix bug")

26. Visualizações Interativas

O EELisp pode renderizar componentes de UI interativos diretamente na saída do REPL.

Browse (visualização em tabela)

;; Navegar por todos os registros em uma grade rolável
(browse tasks)

;; Com filtros e ordenação
(browse tasks :where "done = ?" :params (list false) :order "priority")

Edit (formulário CRUD)

;; Abrir um formulário interativo para criar/ler/atualizar/excluir
(edit tasks)

;; Com filtros
(edit tasks :where "priority = ?" :params (list 1))

O formulário mostra um registro por vez com navegação Anterior/Próximo, edição inline, e botões Salvar, Novo e Excluir.

Formulários computados (defform)

;; Formulário de calculadora independente com campos computados
(defform loan-calc
  (principal:number rate:number years:number)
  :computed (
    (monthly-payment
      (let ((r (/ rate 1200))
            (n (* years 12)))
        (round (/ (* principal r (pow (+ 1 r) n))
                  (- (pow (+ 1 r) n) 1)) 2)))
    (total-paid
      (round (* monthly-payment (* years 12)) 2))))

Campos computados são atualizados automaticamente quando os campos de entrada mudam.

Campos de escolha (dropdown)

Use a sintaxe (name:choice "opt1" "opt2" ...) para criar um seletor dropdown:

(defform new-task
  (title:string
   (priority:choice "low" "medium" "high" "urgent")
   (status:choice "todo" "in-progress" "done")
   notes:memo))

Campos de escolha são renderizados como um menu dropdown na interface do formulário.

Formulários vinculados a tabelas (:source)

Vincule um formulário a uma tabela de banco de dados existente com :source para habilitar CRUD completo:

;; Criar uma tabela primeiro
(deftable projects (name:string status:string budget:number))
(insert projects {:name "Alpha" :status "active" :budget 50000})

;; Formulário vinculado à tabela com dropdown para status
(defform project-editor
  (name:string
   (status:choice "planning" "active" "completed")
   budget:number)
  :source projects)

O formulário carrega registros da tabela de origem com navegação Anterior/Próximo, e botões Salvar, Novo e Excluir — como (edit table) mas com tipos de campo personalizados.

27. Gerenciamento de Banco de Dados

Conexão automática

• Quando você abre uma pasta contendo eelisp.db, o REPL conecta automaticamente a ele.
• Se nenhum arquivo de banco de dados existir, o REPL usa um banco de dados em memória.

Comandos de banco de dados do REPL

28. Itens

O sistema de agenda é um gerenciador de informações pessoais inspirado no Lotus Agenda. Itens são entradas de texto livre com metadados opcionais.

Adicionando itens

(add-item "Finish quarterly report")

;; Com metadados
(add-item "Call dentist" :when "2026-03-01" :priority 2)
(add-item "Buy groceries" :category "personal" :notes "milk, eggs")

;; Adicionar com a data de hoje
(add-item-today "Review pull requests" :priority 1)

Consultando itens

(items)                          ; todos os itens (visualização em tabela)
(items :category "work")        ; filtrar por categoria
(items :search "quarterly")     ; busca por texto
(items :priority 1)             ; filtrar por prioridade
(items :when-before "2026-03-01") ; vencimento antes da data

Gerenciando itens

29. Categorias

As categorias são hierárquicas (use separadores /) e opcionalmente exclusivas (o item pode estar em apenas um filho).

;; Categorias hierárquicas
(defcategory work)
(defcategory work/projects)
(defcategory work/meetings)
(defcategory personal)
(defcategory personal/errands)

;; Exclusiva: item pode estar em apenas um filho
(defcategory priority :exclusive true
  :children (high medium low))

;; Atribuir / desatribuir
(assign 1 "work/projects")
(assign 1 "priority/high")
(unassign 1 "personal")

;; Ver árvore de categorias
(categories)

30. Regras de Auto-Categorização

Regras categorizam automaticamente itens com base em seu conteúdo — o recurso principal do Lotus Agenda.

;; Regras de correspondência de texto
(defrule urgent-flag
  :when (str-contains text "URGENT")
  :assign "priority/high")

(defrule meeting-detect
  :when (or (str-contains text "meeting")
            (str-contains text "call with"))
  :assign "work/meetings")

;; Regex com extração de data
(defrule date-extract
  :when (str-matches text "\\b(\\d{4}-\\d{2}-\\d{2})\\b")
  :action (item-set id :when (match 1)))

;; Aplicar regras
(apply-rules)      ; aplicar em lote a todos os itens
(apply-rules 42)   ; aplicar ao item #42

;; Auto-aplicar em cada add-item
(auto-categorize true)

Gerenciamento de regras

31. Visualizações

Visualizações são consultas salvas que filtram, ordenam e agrupam itens dinamicamente.

(defview work-board
  :source items
  :filter (has-category "work")
  :group-by category
  :sort-by when)

(defview urgent
  :source items
  :filter (= priority "1")
  :sort-by when)

(defview inbox
  :source items
  :filter (= (length categories) 0))

;; Mostrar uma visualização
(show work-board)
(show urgent)

32. Consultas de Calendário

;; Itens para uma data específica
(items-on "2026-02-24")

;; Itens em um intervalo de datas
(items-between "2026-02-24" "2026-02-28")

;; Usando auxiliares de data
(items-on (today))
(items-between (today) (date-add (today) 7 :days))

33. Entrada Inteligente

O comando add analisa linguagem natural para extrair datas, prioridades e pessoas automaticamente.

(add "Meet Alice tomorrow for coffee !!")
; → :when = tomorrow, :priority 2, :who "Alice"

(add "Call Bob next Monday about the project")
; → :when = next Monday, :who "Bob"

(add "URGENT fix server crash")
; → :priority 1

;; Visualizar sem criar
(smart-parse "email Sarah March 15 about renewal !!")
; → {:text "email Sarah about renewal" :when "2026-03-15" :priority 2 :who ("Sarah")}

Padrões reconhecidos

• Datas: datas ISO, tomorrow/today/yesterday, next Monday, this weekend, in 3 days, end of week/month, March 15
• Prioridade: URGENT/ASAP, !!!/!!/!, high/low priority
• Pessoas: @name, with/for/from Name, call/email/meet Name

34. Itens Recorrentes & Modelos

Recorrência

;; Intervalos integrados
(add-item "Team standup" :when (today) :recur :daily)
(add-item "Weekly review" :when (today) :recur :weekly)
(add-item "Monthly report" :when (today) :recur :monthly)

;; Intervalo personalizado
(add-item "Check filters" :when (today) :recur (every 3 :months))

;; Quando você marca como concluído, a próxima ocorrência é criada automaticamente
(item-done 1)  ; cria a próxima recorrência automaticamente

Modelos

;; Definir um modelo reutilizável de item
(deftemplate weekly-review
  :text "Weekly review"
  :category "work"
  :priority 2
  :recur :weekly)

;; Criar a partir do modelo com substituições
(from-template weekly-review :when "2026-03-01")

;; Gerenciar modelos
(templates)           ; listar todos
(drop-template weekly-review)  ; excluir

35. Múltiplas Agendas

Abra, alterne entre e gerencie múltiplos bancos de dados de agenda. Útil para separar agendas de trabalho e pessoais.

;; Abrir uma nova agenda
(open-agenda "work.db")
(open-agenda "personal.db")

;; Alternar entre agendas
(use-agenda "work")

;; Listar todas as agendas abertas
(agendas)  ; mostra marcador ativo (*)

;; Fechar uma agenda
(close-agenda "personal")

Exportar & Importar

;; Exportar para backup ou migração
(export-agenda "work" :format :json :path "work-backup.json")

;; Importar de uma exportação anterior
(import-agenda "work-backup.json")

36. Integração GUI & EELisp

A interface gráfica do EEditor se integra com o EELisp através do método eval() do interpretador. Todos os dados fluem através de expressões EELisp — a GUI nunca acessa o SQLite diretamente.

Arquitetura

┌─────────────────────────┐
│  SwiftUI Views          │
│  (Sidebar, Calendar,    │
│   Agenda, REPL)         │
├─────────────────────────┤
│  ViewModels             │
│  (call interpreter.eval)│
├─────────────────────────┤
│  EELisp Interpreter     │
│  (builtins, prelude)    │
├─────────────────────────┤
│  SQLite Database        │
│  (eelisp.db)            │
└─────────────────────────┘

Como funciona

• REPL — o usuário digita expressões diretamente, os resultados são renderizados como texto, tabelas ou formulários.
• Barra lateral da Agenda — chama (items), (items-on), (items-between) para carregar itens para exibição.
• Calendário — chama (items-between start end) para contar itens da agenda por dia.
• Formulários interativos — browse e edit retornam valores .tableView / .formView que o REPL renderiza como componentes SwiftUI.

Exemplo de fluxo de dados

;; 1. Usuário adiciona itens no REPL
(add-item "Review PRs" :when (today) :priority 1)

;; 2. Alterna para a barra lateral da Agenda → GUI chama:
;;    interpreter.eval("(items-between startKey endKey)")
;;    Analisa resultados em structs AgendaDisplayItem

;; 3. Alterna para o Calendário → GUI chama:
;;    interpreter.eval("(items-on \"2026-02-23\")")
;;    Conta itens por dia para indicadores de ponto

Dicas para iOS & iPadOS

• Barra de ações — uma barra de ferramentas horizontal acima do editor fornece acesso com um toque a Carimbo de Data/Hora, Buscar, Diário, Semanal, Pesquisar, Abertura Rápida, Visualizar, PDF, REPL e Atalhos.
• Barra de ferramentas do REPL — navegação pelo histórico, snippets rápidos, Carregar Arquivo e Limpar.
• Teclado externo — todos os atalhos ⌘ funcionam com um teclado físico no iPad.
• Menus de contexto — pressione e segure em arquivos ou abas para renomear, excluir, fixar e outras ações.
• Split View — o EEditor funciona no Split View e Slide Over do iPadOS.