Manual de EEditor

1. Primeros pasos

Cuando inicias EEditor por primera vez, ves un editor vacío con una barra lateral. Tres pasos para empezar:

1. Abrir una carpeta — pulsa ⌘O o toca el icono de carpeta. EEditor escanea el directorio y muestra todos los archivos en el árbol de la barra lateral.
2. Seleccionar un archivo — haz clic en cualquier archivo de la barra lateral para abrirlo en una nueva pestaña.
3. Empezar a escribir — los cambios se guardan automáticamente tras 1 segundo de inactividad. Pulsa ⌘S para guardar inmediatamente.

Abrir archivos individuales

Usa ⌘⇧O para abrir un archivo individual desde cualquier ubicación del disco. El directorio padre del archivo se convierte en la carpeta activa.

2. El Editor

EEditor proporciona un entorno de escritura libre de distracciones con resaltado de sintaxis en tiempo real para Markdown y más de 24 lenguajes de programación.

• Resaltado de sintaxis — los encabezados, negrita, cursiva, bloques de código, enlaces y más se muestran con colores en Markdown. Los archivos de código tienen resaltado de palabras clave, tipos, cadenas, números y comentarios.
• Buscar y reemplazar (⌘F) — busca dentro del documento actual, reemplaza una o todas las coincidencias.
• Insertar marca de tiempo (⌘I) — inserta YYYY-MM-DD HH:mm en la posición del cursor.
• Deshacer / Rehacer — ⌘Z / ⌘⇧Z.
• Indicador de lenguaje — el lenguaje detectado se muestra en la esquina inferior derecha.
• Wiki-links — coloca el cursor sobre [[nombre_archivo]] y pulsa ⌘O para abrir ese archivo.
• Enviar al REPL (⌘R) — selecciona texto en el editor y pulsa ⌘R para rellenar la entrada del REPL. Pulsa Enter para evaluar.

3. Barra lateral y árbol de archivos

La barra lateral muestra una vista jerárquica de tu carpeta. Los directorios se ordenan primero, luego los archivos alfabéticamente.

• Expandir/contraer carpetas — haz clic en el triángulo de expansión.
• Crear un nuevo archivo (⌘N) — introduce un nombre como subcarpeta/archivo.md para crear archivos anidados.
• Crear una nueva carpeta — usa el botón de carpeta + en la barra de herramientas.
• Eliminar — clic derecho → Eliminar (se mueve a la Papelera en macOS).
• Renombrar — clic derecho → Renombrar.
• Actualizar (⌘⇧R) — vuelve a escanear el directorio manteniendo el estado de expansión.
• Ejecutar en el REPL — clic derecho en un archivo .el o .lisp para ejecutarlo.
• Mostrar en Finder (macOS) — clic derecho para mostrar en Finder.
• Indicador de cambios — aparece un punto junto a los archivos con cambios sin guardar.

La barra lateral tiene tres modos mediante el control segmentado: Archivos, Calendario y Agenda.

4. Pestañas y archivos fijados

Cada archivo se abre como una pestaña en la parte superior del editor.

Las pestañas fijadas muestran un icono de pin, aparecen primero (ordenadas alfabéticamente) y no se pueden cerrar hasta que se desfijen. Se restauran automáticamente al reiniciar.

5. Búsqueda y apertura rápida

Búsqueda de texto completo (⌘⇧F)

• Busca en todos los archivos del espacio de trabajo.
• Resultados agrupados por archivo con números de línea y contexto.
• Activa el modo sensible a mayúsculas con el botón Aa.
• Haz clic en un resultado para abrir el archivo en esa ubicación.

Apertura rápida (⌘P)

• Coincidencia difusa de nombres de archivo — los resultados se actualizan mientras escribes.
• Teclas de flecha para navegar, Enter para abrir, Escape para cancelar.
• Las coincidencias de prefijo tienen mayor prioridad; los nombres más cortos desempatan.
• Prerrellenado con selección: si hay texto seleccionado en el editor, ⌘P prerrellena la búsqueda.

Wiki-links (⌘O)

Coloca el cursor sobre un enlace [[nombre_archivo]] y pulsa ⌘O para abrir ese archivo directamente.

6. Vista previa y exportación a PDF

Vista previa de Markdown (⌘⇧P)

• Renderiza tu documento como HTML con estilo y soporte para modo oscuro/claro.
• En macOS la vista previa se abre en un marco; en iOS aparece como una hoja.

Exportación a PDF (⌘⇧E)

• Genera un documento A4 listo para imprimir (595 × 842 pt) con tipografía limpia.
• macOS: diálogo de guardado con nombre de archivo sugerido. iOS: hoja para compartir.

7. Notas diarias y planificador semanal

Nota diaria (⌘D)

• Crea YYYY-MM-DD.md en la raíz del proyecto, prerrellenado con un encabezado de fecha.
• Abre el archivo existente si ya existe.

Planificador semanal (⌘⇧W)

• Crea Week of YYYY-MM-DD.md (lunes de la semana actual).
• Prerrellenado con una plantilla estructurada: lunes–domingo, secciones de mañana/tarde/noche.

8. Vista de calendario

Cambia la barra lateral al modo Calendario usando el control segmentado.

• Una cuadrícula mensual muestra el mes actual (lunes primero, ISO 8601).
• Indicadores de doble punto: punto azul = actividad de archivos, punto naranja = elementos de agenda.
• Navega entre meses con los botones < / >. Hoy salta al mes actual.
• Haz clic en un día para ver los archivos modificados ese día y los elementos de agenda programados para esa fecha.

9. Barra lateral de agenda

Cambia al modo Agenda mediante el icono del portapapeles. El panel muestra tu programación próxima en tres secciones:

• Vencidos — elementos con una fecha :when anterior a hoy.
• Hoy — elementos programados para hoy.
• Próximos 7 días — elementos próximos dentro de la semana.

Cada elemento muestra un punto de prioridad (rojo = urgente, naranja = alta, amarillo = media, gris = normal), texto, categorías y fecha formateada. Toca actualizar para recargar después de añadir elementos en el REPL.

Barra lateral del REPL

El REPL es un panel en la barra lateral derecha que coexiste con el editor. Altérnalo con ⌘⇧L o el icono de terminal en la barra de herramientas.

• Funcionalidad completa del REPL: prompt de entrada, soporte multilínea, historial persistente, formularios en línea y tablas.
• Permanece abierto mientras cambias entre archivos, abres nuevas pestañas y navegas — no se cierra hasta que lo cierres explícitamente.
• El estado de la barra lateral persiste entre sesiones — si estaba abierto al salir, reaparece al reiniciar.
• Útil para cálculos rápidos, consultas de datos, gestión de bases de datos o ejecución de scripts junto a tus documentos.

Bloques de código EELisp en Markdown

Incorpora código EELisp ejecutable directamente en tus archivos Markdown usando bloques de código delimitados:

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

Ejecutar un bloque de código

1. Coloca el cursor en cualquier lugar dentro de un bloque ```eelisp.
2. Pulsa ⌘⇧Return (o usa el menú: Vista → Ejecutar bloque EELisp).
3. El resultado aparece como un bloque ```result inmediatamente debajo.

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

Volver a ejecutar reemplaza el resultado existente. El resultado se inserta como texto plano (no en un bloque de código) y se selecciona automáticamente para que puedas usar ⌘C para copiar o ⌘X para cortar inmediatamente.

Formularios y tablas en el editor

Cuando un bloque EELisp devuelve un formulario (edit, defform) o una tabla (browse), se abre como un panel lateral interactivo junto al editor en lugar de insertar texto plano. Puedes interactuar con el formulario — navegar registros, editar campos, guardar — manteniendo tu documento visible. Se inserta igualmente una línea de resumen en el documento.

Los casos de uso incluyen cálculos en línea, añadir elementos de agenda desde entradas de diario, consultar datos y operaciones con archivos:

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

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

10. Atajos de teclado

Pulsa ⌘? en la aplicación para ver la hoja completa de atajos. Aquí está la referencia completa:

Archivos

Navegación

Pestañas

Edición

Vista y exportación

11. Uso del REPL

EEditor incluye un intérprete Lisp integrado llamado EELisp — diseñado para la gestión de datos personales, cálculos y scripting.

Abrir el REPL

• Pulsa ⌘⇧L para alternar la barra lateral del REPL, o toca el icono de terminal en la barra de herramientas.
• Si tienes texto seleccionado en el editor, ⌘⇧L lo envía al campo de entrada del REPL automáticamente.
• El REPL se abre como un panel en la barra lateral derecha que permanece abierto mientras cambias entre archivos y pestañas.
• El estado de la barra lateral persiste entre sesiones — si estaba abierto al salir, reaparece al reiniciar.
• Pulsa ⌘⇧L de nuevo o haz clic en el botón × en el encabezado del REPL para cerrarlo.

Evaluar expresiones

• Escribe una expresión en el prompt > y pulsa ⌘Return para evaluar.
• Entrada multilínea — si los paréntesis están desbalanceados, el prompt cambia a .. y espera más entrada. Una barra de pistas muestra ⌘↩ para ejecutar · ⎋ para cancelar.
• Historial — pulsa Arriba/Abajo para navegar por los comandos anteriores. El historial se conserva entre sesiones (hasta 100 entradas).
• Seleccionar y copiar — el texto de salida es seleccionable. Clic derecho → Copiar toda la salida.

Enviar al REPL (⌘R o ⌘⇧L)

Selecciona texto en el editor y pulsa ⌘R o ⌘⇧L. La barra lateral del REPL se abre con tu selección prerrellenada en el campo de entrada, lista para que pulses ⌘Return para evaluar.

Comandos de base de datos

EELisp incluye funciones integradas y comandos del REPL para gestionar bases de datos:

Cargar archivos

Usa :load path/to/file.el para cargar y evaluar un script EELisp. En iOS, toca el botón Cargar en la barra de herramientas o haz clic derecho en un archivo .el en la barra lateral.

Barra de herramientas en iOS

En iOS/iPadOS, aparece una barra de herramientas con: navegación del historial (↑/↓), fragmentos rápidos (query, deftable, defn), Cargar archivo y Limpiar.

12. Comandos del REPL

Los comandos con prefijo de dos puntos controlan el propio REPL (no son expresiones EELisp):

13. Aritmética y matemáticas

Todos los operadores aritméticos son variádicos (aceptan múltiples argumentos) y funcionan con enteros y decimales.

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

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

14. Comparación y lógica

Operadores lógicos

Estas son formas especiales (evaluación en cortocircuito):

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

;; Cortocircuito: (or) devuelve el primer valor verdadero
(or nil false 42 99)    ; → 42

15. Variables y funciones

Definir variables

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

Definir funciones

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

(square 5)  ; → 25

;; Cuerpo con múltiples expresiones (se devuelve el último valor)
(defn greet (name)
  (def msg (str "Hello, " name "!"))
  (println msg)
  msg)

Funciones 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

Enlaces locales

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

16. Flujo de control

if

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

cond

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

when

;; Ejecutar el cuerpo solo si la condición es verdadera
(when (> x 0)
  (println "positive!")
  x)

loop / recur

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

begin

;; Evaluar múltiples expresiones, devolver la última
(begin
  (def a 10)
  (def b 20)
  (+ a b))  ; → 30

17. Cadenas de texto

18. Listas

;; Encadenar operaciones de listas
(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. Diccionarios

Los diccionarios usan claves de tipo keyword (:name) y son inmutables — las operaciones devuelven nuevos diccionarios.

(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 y conversión

Predicados de tipo

Inspección de tipos

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

Funciones de conversión

21. E/S & Fechas

Salida

Funciones de fecha

(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. Funciones del Preludio

Estas funciones están definidas en el propio EELisp y se cargan automáticamente al inicio:

23. HTTP & JSON

;; Obtener datos de una API
(def resp (http-get "https://api.example.com/data"))
(def data (json-parse (dict-get resp :body)))

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

Evaluación

Sistema de Archivos

EELisp puede leer y escribir archivos en la carpeta abierta. Todas las rutas son relativas al directorio del espacio de trabajo actual.

;; Leer un archivo
(def content (read-file "notes.md"))

;; Escribir resultados en un archivo
(write-file "output.txt" (str "Report: " (today)))

;; Añadir a un registro
(append-file "log.txt" (str (today) " - Done\n"))

;; Listar archivos del espacio de trabajo
(list-files)       ; → ("README.md" "notes.md" ...)
(list-files "src") ; → ("main.el" "utils.el" ...)

Integración con el Editor

Estas funciones nativas permiten que el código EELisp interactúe con el búfer del editor activo.

;; Insertar texto en el cursor
(insert-at (cursor-pos) (str "Updated: " (today)))

;; Obtener lo seleccionado
(def sel (selection))

;; Leer el búfer completo
(def text (buffer-text))
(println (str "Length: " (str-len text)))

Portapapeles

;; Copiar un resultado al portapapeles
(clipboard-set (str "Total: $" (reduce + 0 '(10 20 30))))

;; Pegar y procesar el contenido del portapapeles
(str-upper (clipboard-get))

24. Definición de Tablas

EELisp incluye un motor de base de datos SQLite integrado. Las tablas se definen con esquemas tipados.

Sintaxis básica

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

Tipos de campo

Gestión de tablas

;; Ejemplo completo
(deftable tasks (title:string priority:number done:bool due:date))
(tables)       ; → (tasks)
(describe tasks) ; → detalles del esquema

25. Registros & Consultas

Inserción de registros

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

Consultas

;; Todos los registros
(query tasks)

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

;; Ordenados y limitados
(query tasks :order "priority" :limit 5)

;; Seleccionar columnas específicas
(query tasks :select "title, done")

;; Orden descendente
(query tasks :order "priority" :asc false)

Actualización y eliminación

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

;; Borrado lógico (estilo dBASE, se puede recuperar)
(delete tasks 1)

;; Eliminar permanentemente los registros borrados lógicamente
(pack tasks)

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

Acceso a registros

;; Trabajar con resultados de consulta programáticamente
(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. Vistas Interactivas

EELisp puede renderizar componentes de interfaz interactivos directamente en la salida del REPL.

Browse (vista de tabla)

;; Explorar todos los registros en una cuadrícula desplazable
(browse tasks)

;; Con filtros y ordenación
(browse tasks :where "done = ?" :params (list false) :order "priority")

Edit (formulario CRUD)

;; Abrir un formulario interactivo para crear/leer/actualizar/eliminar
(edit tasks)

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

El formulario muestra un registro a la vez con navegación Anterior/Siguiente, edición en línea, y botones Guardar, Nuevo y Eliminar.

Formularios calculados (defform)

;; Formulario calculador independiente con campos calculados
(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))))

Los campos calculados se actualizan automáticamente cuando cambian los campos de entrada.

Campos de selección (desplegable)

Usa la sintaxis (name:choice "opt1" "opt2" ...) para crear un selector desplegable:

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

Los campos de selección se renderizan como un menú desplegable en la interfaz del formulario.

Formularios vinculados a tablas (:source)

Vincula un formulario a una tabla de base de datos existente con :source para habilitar CRUD completo:

;; Crear una tabla primero
(deftable projects (name:string status:string budget:number))
(insert projects {:name "Alpha" :status "active" :budget 50000})

;; Formulario respaldado por la tabla con desplegable para estado
(defform project-editor
  (name:string
   (status:choice "planning" "active" "completed")
   budget:number)
  :source projects)

El formulario carga registros de la tabla de origen con navegación Anterior/Siguiente, y botones Guardar, Nuevo y Eliminar — como (edit table) pero con tipos de campo personalizados.

27. Gestión de Base de Datos

Conexión automática

• Cuando abres una carpeta que contiene eelisp.db, el REPL se conecta automáticamente.
• Si no existe ningún archivo de base de datos, el REPL usa una base de datos en memoria.

Comandos de base de datos del REPL

28. Elementos

El sistema de agenda es un gestor de información personal inspirado en Lotus Agenda. Los elementos son entradas de texto libre con metadatos opcionales.

Añadir elementos

(add-item "Finish quarterly report")

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

;; Añadir con la fecha de hoy
(add-item-today "Review pull requests" :priority 1)

Consultar elementos

(items)                          ; todos los elementos (vista de tabla)
(items :category "work")        ; filtrar por categoría
(items :search "quarterly")     ; búsqueda de texto
(items :priority 1)             ; filtrar por prioridad
(items :when-before "2026-03-01") ; con fecha anterior a

Gestionar elementos

29. Categorías

Las categorías son jerárquicas (usan separadores /) y opcionalmente exclusivas (un elemento solo puede estar en una hija).

;; Categorías jerárquicas
(defcategory work)
(defcategory work/projects)
(defcategory work/meetings)
(defcategory personal)
(defcategory personal/errands)

;; Exclusiva: el elemento solo puede estar en una hija
(defcategory priority :exclusive true
  :children (high medium low))

;; Asignar / desasignar
(assign 1 "work/projects")
(assign 1 "priority/high")
(unassign 1 "personal")

;; Ver el árbol de categorías
(categories)

30. Reglas de Auto-Categorización

Las reglas categorizan automáticamente los elementos basándose en su contenido — la función estrella de Lotus Agenda.

;; Reglas de coincidencia 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 con extracción de fechas
(defrule date-extract
  :when (str-matches text "\\b(\\d{4}-\\d{2}-\\d{2})\\b")
  :action (item-set id :when (match 1)))

;; Aplicar reglas
(apply-rules)      ; aplicar en lote a todos los elementos
(apply-rules 42)   ; aplicar al elemento #42

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

Gestión de reglas

31. Vistas

Las vistas son consultas guardadas que filtran, ordenan y agrupan elementos dinámicamente.

(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 una vista
(show work-board)
(show urgent)

32. Consultas de Calendario

;; Elementos para una fecha específica
(items-on "2026-02-24")

;; Elementos en un rango de fechas
(items-between "2026-02-24" "2026-02-28")

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

33. Entrada Inteligente

El comando add analiza lenguaje natural para extraer fechas, prioridades y personas automáticamente.

(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

;; Vista previa sin crear
(smart-parse "email Sarah March 15 about renewal !!")
; → {:text "email Sarah about renewal" :when "2026-03-15" :priority 2 :who ("Sarah")}

Patrones reconocidos

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

34. Elementos Recurrentes & Plantillas

Recurrencia

;; 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))

;; Al marcar como completado, la siguiente ocurrencia se crea automáticamente
(item-done 1)  ; crea la siguiente recurrencia automáticamente

Plantillas

;; Definir un modelo de elemento reutilizable
(deftemplate weekly-review
  :text "Weekly review"
  :category "work"
  :priority 2
  :recur :weekly)

;; Crear a partir de plantilla con modificaciones
(from-template weekly-review :when "2026-03-01")

;; Gestionar plantillas
(templates)           ; listar todas
(drop-template weekly-review)  ; eliminar

35. Múltiples Agendas

Abre, cambia entre y gestiona múltiples bases de datos de agenda. Útil para separar agendas de trabajo y personales.

;; Abrir una nueva agenda
(open-agenda "work.db")
(open-agenda "personal.db")

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

;; Listar todas las agendas abiertas
(agendas)  ; muestra el marcador activo (*)

;; Cerrar una agenda
(close-agenda "personal")

Exportar e Importar

;; Exportar para copia de seguridad o migración
(export-agenda "work" :format :json :path "work-backup.json")

;; Importar desde una exportación anterior
(import-agenda "work-backup.json")

36. Integración GUI & EELisp

La interfaz gráfica de EEditor se integra con EELisp a través del método eval() del intérprete. Todo el flujo de datos pasa por expresiones EELisp — la interfaz gráfica nunca accede directamente a SQLite.

Arquitectura

┌─────────────────────────┐
│  Vistas SwiftUI          │
│  (Barra lateral, Calendario, │
│   Agenda, REPL)         │
├─────────────────────────┤
│  ViewModels             │
│  (llaman a interpreter.eval)│
├─────────────────────────┤
│  Intérprete EELisp      │
│  (builtins, preludio)   │
├─────────────────────────┤
│  Base de datos SQLite   │
│  (eelisp.db)            │
└─────────────────────────┘

Cómo funciona

• REPL — el usuario escribe expresiones directamente, los resultados se muestran como texto, tablas o formularios.
• Barra lateral de Agenda — llama a (items), (items-on), (items-between) para cargar elementos y mostrarlos.
• Calendario — llama a (items-between start end) para contar los elementos de agenda por día.
• Formularios interactivos — browse y edit devuelven valores .tableView / .formView que el REPL renderiza como componentes SwiftUI.

Ejemplo de flujo de datos

;; 1. El usuario añade elementos en el REPL
(add-item "Review PRs" :when (today) :priority 1)

;; 2. Cambiar a la barra lateral de Agenda → la GUI llama a:
;;    interpreter.eval("(items-between startKey endKey)")
;;    Analiza los resultados en estructuras AgendaDisplayItem

;; 3. Cambiar al Calendario → la GUI llama a:
;;    interpreter.eval("(items-on \"2026-02-23\")")
;;    Cuenta los elementos por día para los indicadores de puntos

Consejos para iOS e iPadOS

• Barra de acciones — una barra de herramientas horizontal sobre el editor que proporciona acceso con un toque a Marca temporal, Buscar, Diario, Semanal, Búsqueda, Apertura rápida, Vista previa, PDF, REPL y Atajos.
• Barra de herramientas del REPL — navegación por historial, fragmentos rápidos, Cargar archivo y Limpiar.
• Teclado externo — todos los atajos con ⌘ funcionan con un teclado físico en iPad.
• Menús contextuales — mantén pulsado sobre archivos o pestañas para renombrar, eliminar, fijar y otras acciones.
• Split View — EEditor funciona en Split View y Slide Over de iPadOS.