EEditor

1. Getting Started

When you first launch EEditor, you will see an empty editor with a sidebar. To begin working:

1. Open a folder — press ⌘O or tap the folder icon in the sidebar to choose a directory. EEditor will scan it and display all files in the sidebar tree.
2. Select a file — click any file in the sidebar to open it in the editor. The file opens in a new tab.
3. Start writing — edits are auto-saved after 1 second of inactivity. You can also press ⌘S to save immediately.

2. The Editor

EEditor provides a distraction-free writing environment with real-time syntax highlighting.

• Syntax highlighting — headings, bold, italic, code blocks, links, and more are color-coded in real time for Markdown. For code files, keywords, types, strings, numbers, and comments are highlighted across 24+ languages.
• Find & Replace — press ⌘F to open the find bar. Type to search, use the replace field to substitute matches.
• Insert timestamp — press ⌘I to insert the current date and time (YYYY-MM-DD HH:mm) at the cursor position.
• Undo / Redo — ⌘Z to undo, ⌘⇧Z to redo.
• Language badge — the detected language is shown in the bottom-right corner of the editor.

3. Sidebar & File Tree

The sidebar shows a hierarchical view of your folder. Directories are sorted first, then files alphabetically.

• Expand/collapse folders by clicking the disclosure triangle.
• Create a new file — press ⌘N or use the + button. You can type a path like subfolder/file.md to create nested files.
• Create a new folder — use the folder + button in the sidebar toolbar.
• Delete — right-click (or long-press on iOS) and select Delete. On macOS, files are moved to the Trash.
• Rename — use the context menu to rename files or folders.
• Refresh — press ⌘⇧R to rescan the directory.
• Dirty indicator — a small dot appears next to files with unsaved changes.

The sidebar has three modes accessible via the segmented toggle at the top: Files (file tree), Calendar (see section 8), and Agenda (see section 8b).

4. Tabs & Pinned Files

Each file you open appears as a tab at the top of the editor area.

• Switch tabs — click a tab, or use ⌘⌥→ (next) and ⌘⌥← (previous). Navigation wraps around.
• Close a tab — click the × button on the tab or press ⌘W. Unsaved changes are saved automatically before closing.
• Close all unpinned — press ⌘⌥W to close every tab except pinned ones.
• Pin a tab — press ⌘⇧K or right-click the tab and select Pin. Pinned tabs show a pin icon and cannot be closed (unpin first). Pinned tabs are restored when you relaunch the app.

5. Search & Quick Open

Full-text search (⌘⇧F) searches across all files in your workspace:

• Results show file name, line number, match count, and context (the lines around each match).
• Toggle case-sensitive mode with the Aa button.
• Click any result to open the file at that location.

Quick Open (⌘P) is a fuzzy file finder:

• Start typing a filename — results update instantly.
• Use arrow keys to navigate, Enter to open, Escape to cancel.
• Prefix matches are ranked higher. Shorter names appear first among ties.
• Selection pre-fill: if you have text selected in the editor, pressing ⌘P pre-fills the search with your selection.

Wiki-links (⌘O): place your cursor on a [[filename]] link and press ⌘O to open that file directly. If no wiki-link is detected, the standard Open Folder dialog appears.

6. Preview & PDF Export

Markdown preview (⌘⇧P) renders your document as styled HTML:

• Supports headings, lists, code blocks, links, images, blockquotes, and tables.
• Adapts to your system's dark or light mode.
• On macOS, the preview opens in a frame. On iOS, it appears as a sheet.

PDF export (⌘⇧E) generates a print-ready document:

• A4 page size (595 × 842 points) with clean typography.
• On macOS, a save dialog appears with a suggested filename.
• On iOS/iPadOS, the PDF is presented via the system share sheet.

7. Daily Notes & Weekly Planner

Daily note (⌘D):

• Creates a file named YYYY-MM-DD.md (e.g., 2026-02-19.md) in your root folder.
• Pre-filled with a heading: # 2026-02-19.
• If the file already exists, it simply opens it.

Weekly planner (⌘⇧W):

• Creates a file named YYYY-WEEK-WW.md (e.g., 2026-WEEK-08.md) using ISO 8601 week numbering.
• Pre-filled with a structured template:

  # Week 08 — 2026
  
  ## Monday
  ### Morning
  -
  ### Afternoon
  -
  ### Evening
  -
  
  ## Tuesday
  ...through Sunday

• If the file already exists, it simply opens it.

8. Calendar View

Toggle the sidebar to Calendar mode using the segmented control (folder / calendar / agenda icons) at the top of the sidebar.

• A month grid shows the current month with Monday as the first day of the week (ISO 8601).
• Dual dot indicators appear on each day: a blue dot for file activity and an orange dot for agenda items scheduled on that date.
• Use the < and > buttons to navigate months. The Today button jumps back to the current month.
• Click a day to see files modified that day and agenda items scheduled for that date, organized in separate sections.
• Click a file in the day list to open it in the editor.

8b. Agenda Sidebar

Toggle the sidebar to Agenda mode using the clipboard icon in the segmented control. The agenda panel provides an at-a-glance view of your upcoming schedule:

• Overdue — items with a :when date before today, shown with a red section header.
• Today — items scheduled for today.
• Next 7 Days — upcoming items within the next week.
• Each item shows its priority dot (red = urgent, orange = high, yellow = medium, gray = normal), text, categories, and formatted date.
• Use the refresh button to reload data after adding items in the REPL.

9. EELisp REPL

EEditor includes a built-in Lisp interpreter called EELisp — designed for personal data management.

Opening the REPL:

• Press ⌘⇧L, or tap the terminal icon in the actions bar.
• The REPL opens as a tab alongside your file tabs.

Using the REPL:

• Type an expression at the > prompt and press Enter to evaluate it.
• Multi-line input — if your expression has unbalanced parentheses, the prompt changes to .. and waits for more input. Press Escape (or the × button) to cancel.
• History — press Up/Down arrow to navigate through previous commands.
• Select text — click and drag on any output entry to select and copy text.

Pinning the REPL:

• Right-click the REPL tab and select Pin REPL. A pinned REPL persists across sessions.
• The pin state is saved in UserDefaults and restored on relaunch.

Clearing:

• Right-click the REPL tab → Clear REPL, or use the trash icon on iOS.

10. Database Commands

The REPL includes a SQLite database engine. By default it uses an in-memory database. When you open a folder containing an eelisp.db file, the REPL automatically connects to it for persistent storage (see Database Management). Table names and field definitions are written as bare symbols (no quoting needed).

Define a table:

(deftable tasks (title:string priority:number done:bool due:date))

Field types: string, number, bool, date, memo.

Insert records:

(insert tasks {:title "Write docs" :priority 1 :done false})

Query records:

;; All records
(query tasks)

;; With filters
(query tasks :where "priority <= ?" :params (list 2))

;; Sorted, limited
(query tasks :order "priority" :limit 5)

;; Select specific columns
(query tasks :select "title, done")

Query results are displayed as formatted ASCII tables.

Interactive forms (browse):

;; Open a form to browse, edit, and manage records
(browse tasks)

;; Browse with filters and sorting
(browse tasks :where "done = ?" :params (list false) :order "priority")

The form shows one record at a time with Prev/Next navigation, inline editing, Save, New, and Delete buttons.

Update & delete:

;; Update record by ID
(update tasks 1 {:done true})

;; Soft-delete (dBASE-style)
(delete tasks 1)

;; Purge soft-deleted records
(pack tasks)

Other commands:

Command	Description
(tables)	List all table names
(describe tasks)	Show table schema
(count-records tasks)	Count records (with optional :where)
(drop-table tasks)	Delete a table
(field-get record :name)	Get a field from a record
(record-id record)	Get the record's ID
(records result-set)	Extract record list from query results
(browse table)	Open a navigable table/grid view
(edit table)	Open an interactive CRUD form
(defform name (fields) :computed ...)	Create a calculator form with computed fields

11. Database Management

EELisp supports both in-memory and persistent SQLite databases.

Automatic connection:

• When you open a folder, if an eelisp.db file exists in the root, the REPL automatically connects to it.
• Data you create with deftable and insert is persisted to disk.
• If no database file exists, the REPL uses an in-memory database (data is lost when you close the app).

REPL database commands:

Command	Description
:db	Show the current database path
:db <path>	Switch to a different database file
:db new <name>	Create a new database file in the current folder
:db memory	Switch to an in-memory database

12. Agenda: Items, Categories, Rules & Views

EELisp includes a Lotus Agenda-inspired personal information manager. Add free-form items, auto-categorize with rules, define dynamic views, organize with hierarchical categories, and query with filters — all stored in SQLite.

Adding items:

;; Text-first — just type what's on your mind
(add-item "Finish quarterly report for Sarah")

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

Querying items:

;; Browse all items (interactive table)
(items)

;; Filter by category, search text, priority, or date
(items :category "work")
(items :search "quarterly")
(items :priority 1)
(items :when-before "2026-03-01")

Managing items:

Command	Description
(add-item text :when :priority :category :notes)	Create a new item
(items :category :search :priority :when-before :when-after)	Query items with filters (table view)
(item-get id)	Fetch a single item by ID
(item-edit id)	Open item in form view for editing
(item-set id :field val ...)	Update item properties
(item-done id)	Mark item as done (soft-delete)
(item-count :category cat)	Count items with optional filter

Categories:

Categories are hierarchical (use / separators) and can be mutually exclusive:

;; Hierarchical categories
(defcategory work)
(defcategory work/projects)
(defcategory work/meetings)
(defcategory personal)
(defcategory personal/errands)

;; Exclusive categories (item can only be in one child)
(defcategory priority :exclusive true
  :children (high medium low))

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

;; View the category tree
(categories)

Auto-Categorization Rules:

Define rules that automatically categorize items based on their content — the magic of Lotus Agenda:

;; Text-matching rules
(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")

;; Date extraction via regex
(defrule date-extract
  :when (str-matches text "\\b(\\d{4}-\\d{2}-\\d{2})\\b")
  :action (item-set id :when (match 1)))

;; Apply rules
(apply-rules)            ;; batch-apply to all items
(apply-rules 42)         ;; apply to item #42
(auto-categorize true)   ;; auto-apply on every add-item

Rule management:

Command	Description
(defrule name :when cond :assign cat)	Define a categorization rule
(defrule name :when cond :action expr)	Define a rule with custom action
(apply-rules)	Apply all rules to all items
(apply-rules id)	Apply all rules to a specific item
(auto-categorize true/false)	Toggle auto-apply on insert
(rules)	List all defined rules
(drop-rule name)	Delete a rule

Views — Dynamic Perspectives:

Define saved queries that filter, sort, and group items. Show a view anytime to see the latest matching items:

;; Define views with filter expressions
(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))

;; Show a view
(show work-board)
;; → grouped by category with item counts

(show urgent)
;; → filtered, sorted items

View management:

Command	Description
(defview name :source :filter :group-by :sort-by)	Define a saved view with filter expression
(show view-name)	Display a view's matching items
(views)	List all defined views
(drop-view name)	Delete a view

Date helpers:

Command	Description
(today)	Returns today's date as ISO string (e.g., "2026-02-21")
(date-add date n :days/:weeks/:months)	Add days, weeks, or months to a date
(date-diff date1 date2)	Difference in days between two dates

Calendar Integration:

View items by date and quickly add items for today:

;; View items for a specific date
(items-on "2026-02-24")

;; View items in a date range
(items-between "2026-02-24" "2026-02-28")

;; Quick-add with today's date auto-filled
(add-item-today "Review pull requests" :priority 1)
(add-item-today "Quick grocery run" :notes "milk, bread")

;; Combine with date helpers
(items-on (today))
(items-between (today) (date-add (today) 7 :days))

Command	Description
(items-on "date")	Show items scheduled for a specific date
(items-between "start" "end")	Show items in a date range (inclusive)
(add-item-today text :priority :category :notes)	Add item with today's date auto-filled

Smart Input:

The add command parses natural language to extract dates, priorities, and people automatically:

;; Natural language item creation
(add "Meet Alice tomorrow for coffee !!")
;; → Item with :when = tomorrow, :priority 2, :who "Alice"

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

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

;; Preview without creating an item
(smart-parse "email Sarah March 15 about renewal !!")
;; → {:text "email Sarah about renewal" :when "2026-03-15" :priority 2 :who ("Sarah")}

Command	Description
(add "text")	Smart-add: parse natural language, extract metadata, create item
(smart-parse "text")	Preview extraction without creating an item

HTTP & JSON:

Generic HTTP client and JSON builtins for API integration:

Command	Description
(http-get url)	GET request, returns {:status N :body "..."}
(http-post url body :content-type "...")	POST request with body
(json-parse string)	Parse JSON string to EELisp dict/list
(json-stringify value)	Convert EELisp value to JSON string

Recurring Items & Templates:

Items with recurrence patterns auto-create the next occurrence when marked done. Templates define reusable item blueprints:

Command	Description
(add-item text :recur :weekly)	Create a recurring item (:daily, :weekly, :monthly)
(every N :unit)	Custom interval, e.g. (every 3 :months)
(item-done id)	Mark done; auto-creates next if recurring
(deftemplate name :text "..." :category "..." :priority N)	Define a reusable item template
(from-template name :when "..." ...)	Create item from template with overrides
(templates)	List all defined templates
(drop-template name)	Remove a template

Multiple Agendas:

Open, switch between, and manage multiple agenda databases. Export and import for backup or migration:

Command	Description
(open-agenda "path/to/file.db")	Open a new agenda database and switch to it
(use-agenda name)	Switch to an already-open agenda
(agendas)	List all open agendas with active marker
(close-agenda name)	Close and remove an agenda from the registry
(export-agenda name :format :json :path "file.json")	Export all agenda tables to JSON
(import-agenda "file.json")	Import records from a JSON export

13. EELisp Quick Reference

Variables & functions:

(def x 42)
(defn square (x) (* x x))
(square 5)   ; → 25

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

;; Rest parameters
(defn sum (first . rest)
  (reduce + first rest))

Conditionals & loops:

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

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

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

;; Loop with named-let style
(loop ((i 0) (acc 0))
  (> i 10)
  (recur (+ i 1) (+ acc i)))   ; → 55

Strings:

(str "hello" ", " "world")          ; → "hello, world"
(str-split "a,b,c" ",")            ; → ("a" "b" "c")
(str-join '("a" "b" "c") "-")      ; → "a-b-c"
(str-upper "hello")                 ; → "HELLO"

Lists:

(list 1 2 3)                        ; → (1 2 3)
(cons 0 '(1 2))                     ; → (0 1 2)
(map inc (range 1 6))               ; → (2 3 4 5 6)
(filter even? (range 1 11))         ; → (2 4 6 8 10)
(reduce + 0 '(1 2 3 4 5))          ; → 15
(sort-by id '(3 1 4 1 5))          ; → (1 1 3 4 5)

Dictionaries:

(def d {:name "Alice" :age 30})
(dict-get d :name)                  ; → "Alice"
(dict-set d :age 31)                ; → {:name "Alice" :age 31}
(dict-keys d)                       ; → (:name :age)

Prelude functions:

Function	Description
inc / dec	Increment / decrement by 1
even? / odd?	Parity checks
zero? / pos? / neg?	Sign checks
first / second / third / last	List access
take / drop	Take/drop first n elements
some? / every?	Any/all match predicate
pipe	Threading macro: (pipe 5 inc inc square)
compose	Function composition
partial	Partial application

14. iOS & iPadOS Tips

• Quick Actions Bar — a horizontal toolbar appears above the editor with buttons for Timestamp, Find, Daily, Weekly, Search, Open, Preview, PDF, REPL, and Shortcuts. Tap any button for instant access.
• REPL Toolbar — when the REPL is active, a toolbar appears above the keyboard with history navigation (up/down), quick snippets (query, deftable, defn), and a clear button.
• External keyboard — all keyboard shortcuts work when you connect a hardware keyboard to your iPad.
• Context menus — long-press on files in the sidebar or tabs to access rename, delete, pin, and other actions.
• Split View — EEditor works in iPadOS Split View and Slide Over modes.