!16 · krz/orgstar

Sources/OrgApp/DocumentSession.swift +8 −4

     public var lastError: String?
     public var saveMode: SaveMode = .automatic
     public var autosaveDelay: Duration = .seconds(1)
+    /// Org options for commands the session runs (refile, archive).
+    public var options: EditingOptions = .org
+    /// TODO keywords and priorities for files without their own settings.
+    public var defaults: OrgSettings = .default
     private let fileSystem: FileSystem
     private let recovery: RecoveryStore
             }
             autosave?.cancel()
             self.path = path
-            buffer = StateBuffer(DocumentState(bytes: bytes))
+            buffer = StateBuffer(DocumentState(bytes: bytes, defaults: defaults))
             conflict = nil
             revealRequest = nil
             refresh()
     private func editContext(now: Date) -> EditContext? {
         guard let buffer else { return nil }
         let document = buffer.document
-        return EditContext(revision: document.revision, text: document.text, tree: document.tree, selection: buffer.selection, now: now)
+        return EditContext(revision: document.revision, text: document.text, tree: document.tree, selection: buffer.selection, now: now, options: options)
     }
     /// Moves the subtree at the caret under `target`. For another file, that file is written
         let url = URL(fileURLWithPath: target.path)
         do {
             guard let bytes = try fileSystem.read(url) else { return "\((target.path as NSString).lastPathComponent) no longer exists." }
-            var state = DocumentState(bytes: bytes)
+            var state = DocumentState(bytes: bytes, defaults: defaults)
             guard state.isEditable else { return "\((target.path as NSString).lastPathComponent) isn't UTF-8, so it can't be changed." }
             guard let start = target.locate(in: state) else { return "Can't find \(target.label) any more." }
             guard let result = Refile.toOtherFile(source: context, target: state.text, under: start) else { return "Can't refile from here." }
         do {
             let url = URL(fileURLWithPath: destination.path)
             let existing = destination.isSameFile ? nil : try fileSystem.read(url)
-            var state = DocumentState(bytes: existing ?? [])
+            var state = DocumentState(bytes: existing ?? [], defaults: defaults)
             if !destination.isSameFile, !state.isEditable { return "\(url.lastPathComponent) isn't UTF-8, so it can't be changed." }
             let edits: Archive.Edits
             switch Archive.run(context, sourcePath: path, destination: destination, archiveText: existing.map { _ in state.text }) {

Sources/OrgCore/Commands/Archive.swift +1 −1

	@@ -234,7 +234,7 @@ public enum Archive {
234	formatter.timeZone = context.calendar.timeZone	234	formatter.timeZone = context.calendar.timeZone
235	formatter.dateFormat = "yyyy-MM-dd EEE HH:mm"	235	formatter.dateFormat = "yyyy-MM-dd EEE HH:mm"
236	let time = formatter.string(from: context.now)	236	let time = formatter.string(from: context.now)
237	let archive = destination.isSameFile ? nil : EmacsBuffer(archiveText ?? "", point: 0, settings: context.tree.settings)	237	let archive = destination.isSameFile ? nil : EmacsBuffer(archiveText ?? "", point: 0, settings: context.tree.settings, options: context.options)
238	var archiveEdit: TextEdit?	238	var archiveEdit: TextEdit?
239	let step = commitBuffer(context) { source in	239	let step = commitBuffer(context) { source in
240	let target = archive ?? source	240	let target = archive ?? source

Sources/OrgCore/Commands/Command.swift +27 −1

	@@ -1,5 +1,28 @@
1	import Foundation	1	import Foundation
2		2
		3	/// Org options that change what commands write, as the user's Emacs has them.
		4	public struct EditingOptions: Sendable, Equatable, Codable {
		5	/// `org-tags-column`: negative aligns tags to end at that column, 0 puts them one space
		6	/// after the title.
		7	public var tagsColumn: Int
		8	/// `org-insert-heading-respect-content`: M-RET adds the heading after the subtree.
		9	public var insertHeadingRespectContent: Bool
		10	/// `org-M-RET-may-split-line`: M-RET in the middle of a line splits it.
		11	public var metaReturnMaySplitLine: Bool
		12	/// `org-list-allow-alphabetical`: `a.` and `A)` are list bullets.
		13	public var listAllowAlphabetical: Bool
		14
		15	public init(tagsColumn: Int = -77, insertHeadingRespectContent: Bool = false, metaReturnMaySplitLine: Bool = true, listAllowAlphabetical: Bool = false) {
		16	self.tagsColumn = tagsColumn
		17	self.insertHeadingRespectContent = insertHeadingRespectContent
		18	self.metaReturnMaySplitLine = metaReturnMaySplitLine
		19	self.listAllowAlphabetical = listAllowAlphabetical
		20	}
		21
		22	/// Org's own defaults.
		23	public static let org = EditingOptions()
		24	}
		25
3	/// Everything a command may read. Commands never read the clock or the file system, so the	26	/// Everything a command may read. Commands never read the clock or the file system, so the
4	/// same context always gives the same result.	27	/// same context always gives the same result.
5	public struct EditContext: Sendable {	28	public struct EditContext: Sendable {
	@@ -16,10 +39,12 @@ public struct EditContext: Sendable {
16	public let answers: [String: String]	39	public let answers: [String: String]
17	/// Ranges the view hides (folded text); motion commands skip headings inside them.	40	/// Ranges the view hides (folded text); motion commands skip headings inside them.
18	public let hidden: [Range<Int>]	41	public let hidden: [Range<Int>]
		42	public let options: EditingOptions
19		43
20	public init(	44	public init(
21	revision: Int, text: String, tree: OrgTree, selection: [Range<Int>],	45	revision: Int, text: String, tree: OrgTree, selection: [Range<Int>],
22	now: Date = Date(), calendar: Calendar = .current, answers: [String: String] = [:], hidden: [Range<Int>] = []	46	now: Date = Date(), calendar: Calendar = .current, answers: [String: String] = [:], hidden: [Range<Int>] = [],
		47	options: EditingOptions = .org
23	) {	48	) {
24	self.revision = revision	49	self.revision = revision
25	self.text = text	50	self.text = text
	@@ -29,6 +54,7 @@ public struct EditContext: Sendable {
29	self.calendar = calendar	54	self.calendar = calendar
30	self.answers = answers	55	self.answers = answers
31	self.hidden = hidden	56	self.hidden = hidden
		57	self.options = options
32	}	58	}
33		59
34	public var caret: Int { selection.first?.lowerBound ?? 0 }	60	public var caret: Int { selection.first?.lowerBound ?? 0 }

Sources/OrgCore/Commands/EmacsBuffer.swift +7 −4

     /// Groups of the last successful match, as Emacs's match data.
     var lastMatch: [Range<Int>?] = []
-    init(_ text: String, point: Int, settings: OrgSettings = .default) {
+    let options: EditingOptions
+    init(_ text: String, point: Int, settings: OrgSettings = .default, options: EditingOptions = .org) {
         self.text = NSMutableString(string: text)
         self.point = point
         self.settings = settings
+        self.options = options
         unchangedPrefix = self.text.length
         unchangedSuffix = self.text.length
     }
         let end = lineEnd(offset)
         let line = substring(start, end)
         var plain = LineBuffer(line, caret: nil)
-        OrgCore.alignTags(&plain)
+        OrgCore.alignTags(&plain, tagsColumn: options.tagsColumn)
         guard plain.string != line else { return }
         func map(_ position: Int) -> Int {
             guard position >= start, position <= end else {
                 return position > end ? position + (plain.string as NSString).length - (line as NSString).length : position
             }
             var buffer = LineBuffer(line, caret: position - start)
-            OrgCore.alignTags(&buffer)
+            OrgCore.alignTags(&buffer, tagsColumn: options.tagsColumn)
             return start + buffer.caret!
         }
         let newPoint = map(point)
 /// Runs a buffer-editing body against a context and turns the result into one minimal edit
 /// and the new caret. A user error becomes `.failed`.
 func commitBuffer(_ context: EditContext, _ body: (EmacsBuffer) throws -> Void) -> CommandStep {
-    let buffer = EmacsBuffer(context.text, point: context.caret, settings: context.tree.settings)
+    let buffer = EmacsBuffer(context.text, point: context.caret, settings: context.tree.settings, options: context.options)
     do {
         try body(buffer)
     } catch let error as EmacsBuffer.UserError {

Sources/OrgCore/Commands/HeadingCommands.swift +4 −4

	@@ -247,7 +247,7 @@ public struct TodoCycle: OrgCommand {
247	}	247	}
248	}	248	}
249	buffer.replaceBeforeMarkers(regionStart..<regionEnd, with: next.map { " \($0) " } ?? " ")	249	buffer.replaceBeforeMarkers(regionStart..<regionEnd, with: next.map { " \($0) " } ?? " ")
250	alignTags(&buffer)	250	alignTags(&buffer, tagsColumn: context.options.tagsColumn)
251	}	251	}
252	}	252	}
253	}	253	}
	@@ -295,7 +295,7 @@ struct PriorityChange {
295	buffer.insert(cookie + " ", at: line.titleStart - line.start)	295	buffer.insert(cookie + " ", at: line.titleStart - line.start)
296	}	296	}
297	}	297	}
298	alignTags(&buffer)	298	alignTags(&buffer, tagsColumn: context.options.tagsColumn)
299	}	299	}
300	}	300	}
301		301
	@@ -341,7 +341,7 @@ public struct PromoteHeading: OrgCommand {
341	guard line.level > 1 else { return .failed("Cannot promote to level 0") }	341	guard line.level > 1 else { return .failed("Cannot promote to level 0") }
342	return line.commit(context) { buffer in	342	return line.commit(context) { buffer in
343	buffer.replace(0..<(line.level + 1), with: String(repeating: "*", count: line.level - 1) + " ")	343	buffer.replace(0..<(line.level + 1), with: String(repeating: "*", count: line.level - 1) + " ")
344	alignTags(&buffer)	344	alignTags(&buffer, tagsColumn: context.options.tagsColumn)
345	fixPositionAfterPromote(&buffer, settings: context.tree.settings)	345	fixPositionAfterPromote(&buffer, settings: context.tree.settings)
346	}	346	}
347	}	347	}
	@@ -358,7 +358,7 @@ public struct DemoteHeading: OrgCommand {
358	let line = HeadingLine(heading)	358	let line = HeadingLine(heading)
359	return line.commit(context) { buffer in	359	return line.commit(context) { buffer in
360	buffer.replace(0..<(line.level + 1), with: String(repeating: "*", count: line.level + 1) + " ")	360	buffer.replace(0..<(line.level + 1), with: String(repeating: "*", count: line.level + 1) + " ")
361	alignTags(&buffer)	361	alignTags(&buffer, tagsColumn: context.options.tagsColumn)
362	fixPositionAfterPromote(&buffer, settings: context.tree.settings)	362	fixPositionAfterPromote(&buffer, settings: context.tree.settings)
363	}	363	}
364	}	364	}

Sources/OrgCore/Commands/ListCommands.swift +5 −5

Sources/OrgCore/Commands/OrgList.swift +57 −24

     // MARK: - Context
-    static let itemPattern = "([ \\t]*([-+]|(([0-9]+)[.)]))|[ \\t]+\\*)([ \\t]+|$)"
+    /// `org-item-re`.
-    static let itemBeginningPattern = "^" + itemPattern
+    var itemPattern: String {
+        let alpha = options.listAllowAlphabetical ? "|[A-Za-z]" : ""
+        return "([ \\t]*([-+]|(([0-9]+\(alpha))[.)]))|[ \\t]+\\*)([ \\t]+|$)"
+    }
+    var itemBeginningPattern: String { "^" + itemPattern }
     static let fullItemPattern = "^[ \\t]*((?:[-+*]|(?:[0-9]+|[A-Za-z])[.)])(?:[ \\t]+|$))(?:\\[@(?:start:)?([0-9]+|[A-Za-z])\\][ \\t]*)?(?:(\\[[ X-]\\])(?:[ \\t]+|$))?(?:(.*)[ \\t]+::(?:[ \\t]+|$))?"
     static let listEndPattern = "^[ \\t]*\\n[ \\t]*\\n"
     static let drawerPattern = "^[ \\t]*:([-_\\w]+):[ \\t]*$"
             let context = listContext()
             var reference = looking("^[ \\t]*$") != nil ? 10000 : currentTextIndentation
             if context.kind == .invalid { return nil }
-            if looking(Self.itemPattern) != nil { return point }
+            if looking(itemPattern) != nil { return point }
             // Inside `org-list-end-re`: start above it.
             let windowStart = saveExcursion { forwardLine(-2); return point }
             let windowEnd = saveExcursion { forwardLine(2); return lineEnd(point) }
             }
             while true {
                 let ind = currentTextIndentation
-                if looking(Self.itemPattern) != nil, ind < reference { return point }
+                if looking(itemPattern) != nil, ind < reference { return point }
                 if point <= context.up { return nil }
                 if looking(Self.listEndPattern) != nil { return nil }
                 if looking("^[ \\t]*#\\+end_") != nil, searchBackward("^[ \\t]*#\\+begin_", bound: context.up) != nil {
             beginningOfLine()
             switch listContext().kind {
             case .invalid, .block("comment"), .block("verse"): return false
-            default: return looking(Self.itemPattern) != nil
+            default: return looking(itemPattern) != nil
             }
         }
     }
                 while true {
                     let ind = currentTextIndentation
                     if point <= context.up {
-                        if looking(Self.itemPattern) == nil {
+                        if looking(itemPattern) == nil {
                             trimToBegin()
                         } else {
                             beginCell = (point, ind)
                         trimToBegin()
                         return
                     }
-                    if looking(Self.itemPattern) != nil {
+                    if looking(itemPattern) != nil {
                         items.insert(assocAtPoint(ind), at: 0)
                         ends.insert((ind, point), at: 0)
                         if ind < textMinInd { beginCell = (point, ind) }
                     ends2.append((0, point))
                     break
                 }
-                if looking(Self.itemPattern) != nil {
+                if looking(itemPattern) != nil {
                     items2.append(assocAtPoint(ind))
                     ends2.append((ind, point))
                     forwardLine(1)
     /// `org-list-struct-fix-bul` (alphabetical bullets off).
     func fixBullets(_ structure: inout ListStruct, _ prevs: [Int: Int]) {
+        func find(_ pattern: String, _ string: String) -> Range<String.Index>? {
+            guard let range = string.range(of: pattern, options: .regularExpression) else { return nil }
+            stringMatched(string, range)
+            return range
+        }
         for pos in structure.map(\.pos) {
             let previous = prevs[pos]
             let counter = structure.item(pos)!.counter
             let bullet = structure.bullet(pos)
+            let previousBullet = previous.map { structure.bullet($0) }
+            let alphap = previous == nil && useAlphabeticalBullets(pos, structure, prevs)
             let new: String
-            if let previous, let counter, counter.range(of: "[a-zA-Z]", options: .regularExpression) != nil,
+            if previous != nil, let counter, let previousBullet, find("[a-zA-Z]", counter) != nil, find("[a-zA-Z]", previousBullet) != nil {
-               structure.bullet(previous).range(of: "[a-zA-Z]", options: .regularExpression) != nil {
+                let lower = find("[a-z]", previousBullet)
-                let previousBullet = structure.bullet(previous)
+                let range = lower ?? find("[A-Z]", previousBullet)!
-                let real = previousBullet.range(of: "[a-z]", options: .regularExpression) != nil ? counter.lowercased() : counter.uppercased()
+                new = previousBullet.replacingCharacters(in: range, with: lower != nil ? counter.lowercased() : counter.uppercased())
-                let range = previousBullet.range(of: "[a-zA-Z]", options: .regularExpression)!
+            } else if previous != nil, let counter, let previousBullet, let counterRange = find("[0-9]+", counter),
-                new = previousBullet.replacingCharacters(in: range, with: real)
+                      let range = find("[0-9]+", previousBullet) {
-            } else if let previous, let counter, let counterRange = counter.range(of: "[0-9]+", options: .regularExpression),
+                new = previousBullet.replacingCharacters(in: range, with: counter[counterRange])
-                      let range = structure.bullet(previous).range(of: "[0-9]+", options: .regularExpression) {
+            } else if let previousBullet {
-                new = structure.bullet(previous).replacingCharacters(in: range, with: counter[counterRange])
+                new = incrementBullet(previousBullet)
-            } else if let previous {
+            } else if let counter, useAlphabeticalBullets(pos, structure, prevs), find("[A-Za-z]", counter) != nil, find("[A-Za-z]", bullet) != nil {
-                new = incrementBullet(structure.bullet(previous))
+                let lower = find("[a-z]", bullet)
-            } else if let counter, let counterRange = counter.range(of: "[0-9]+", options: .regularExpression),
+                let range = lower ?? find("[A-Z]", bullet)!
-                      let range = bullet.range(of: "[0-9]+", options: .regularExpression) {
+                new = bullet.replacingCharacters(in: range, with: lower != nil ? counter.lowercased() : counter.uppercased())
+            } else if let counter, let counterRange = find("[0-9]+", counter), let range = find("[0-9]+", bullet) {
                 new = bullet.replacingCharacters(in: range, with: counter[counterRange])
-            } else if let range = bullet.range(of: "([0-9]+|[A-Za-z])", options: .regularExpression) {
+            } else if alphap, let range = find("[A-Z]", bullet) {
-                stringMatched(bullet, range)
+                new = bullet.replacingCharacters(in: range, with: "A")
+            } else if alphap, let range = find("[a-z]", bullet) {
+                new = bullet.replacingCharacters(in: range, with: "a")
+            } else if let range = find("([0-9]+|[A-Za-z])", bullet) {
                 new = bullet.replacingCharacters(in: range, with: "1")
             } else {
                 new = bullet
         }
     }
+    /// `org-list-use-alpha-bul-p`: the list starting at `first` fits in the alphabet.
+    func useAlphabeticalBullets(_ first: Int, _ structure: ListStruct, _ prevs: [Int: Int]) -> Bool {
+        guard options.listAllowAlphabetical else { return false }
+        var item: Int? = first
+        var ascii = 64
+        while let current = item {
+            if let counter = structure.item(current)?.counter, let letter = counter.first, letter.isASCII, letter.isLetter {
+                ascii = Int(letter.uppercased().unicodeScalars.first!.value)
+            } else {
+                ascii += 1
+            }
+            if ascii > 90 { return false }
+            item = structure.nextItem(current, prevs)
+        }
+        return true
+    }
     /// `org-list-struct-fix-ind`.
     func fixIndentation(_ structure: inout ListStruct, _ parents: [(item: Int, parent: Int?)], bulletSize: Int? = nil) {
         let topInd = structure.ind(structure.top)
             point = end
             skipBackward(Self.whitespace)
             beginningOfLine()
-            while point > begin || (point == begin && looking(Self.itemPattern) == nil) {
+            while point > begin || (point == begin && looking(itemPattern) == nil) {
                 if looking("^[ \\t]*\\S", setsMatch: false) != nil {
                     indentLineTo(max(currentTextIndentation + delta, ind.map { $0 + 1 } ?? -1))
                 }

Sources/OrgCore/Commands/Refile.swift +1 −1

	@@ -126,7 +126,7 @@ public enum Refile {
126	}	126	}
127		127
128	public static func toOtherFile(source context: EditContext, target text: String, under heading: Int?) -> Result? {	128	public static func toOtherFile(source context: EditContext, target text: String, under heading: Int?) -> Result? {
129	let target = EmacsBuffer(text, point: 0)	129	let target = EmacsBuffer(text, point: 0, settings: context.tree.settings, options: context.options)
130	var tree = ""	130	var tree = ""
131	let step = commitBuffer(context) { buffer in	131	let step = commitBuffer(context) { buffer in
132	tree = try buffer.copySubtree()	132	tree = try buffer.copySubtree()

Sources/OrgCore/Commands/StructureCommands.swift +5 −3

                 saveExcursion { insert(stars + " \n") }
                 if !(blank && previousLineEmpty) { emptyLinesBeforeCurrent(blank ? 1 : 0) }
                 endOfLine()
-            } else if let match = saveExcursion({ () -> [Range<Int>?]? in beginningOfLine(); return lookingAt(complexHeadingPattern) }),
+            } else if options.metaReturnMaySplitLine,
+                      let match = saveExcursion({ () -> [Range<Int>?]? in beginningOfLine(); return lookingAt(complexHeadingPattern) }),
                       let title = match[4], title.lowerBound <= point, point <= title.upperBound {
                 let split = substring(point, title.upperBound)
                 deleteRegion(point, title.upperBound)
             if !(blank && previousLineEmpty) { emptyLinesBeforeCurrent(blank ? 1 : 0) }
             addBlankAfter(blank)
         } else {
+            if !options.metaReturnMaySplitLine { endOfLine() }
             insert("\n" + stars + " ")
             if !(blank && previousLineEmpty) { emptyLinesBeforeCurrent(blank ? 1 : 0) }
             addBlankAfter(blank)
     public var title: String { "Insert Heading" }
     public func applies(in context: EditContext) -> Bool { true }
     public func run(in context: EditContext) -> CommandStep {
-        headingCommand(context) { try $0.insertHeading(respectContent: false, hidden: context.hidden) }
+        headingCommand(context) { try $0.insertHeading(respectContent: context.options.insertHeadingRespectContent, hidden: context.hidden) }
     }
 }
     public func applies(in context: EditContext) -> Bool { true }
     public func run(in context: EditContext) -> CommandStep {
         headingCommand(context) { buffer in
-            try buffer.insertHeading(respectContent: false, hidden: context.hidden)
+            try buffer.insertHeading(respectContent: context.options.insertHeadingRespectContent, hidden: context.hidden)
             let previous = buffer.saveExcursion { () -> String? in
                 try? buffer.forwardHeadingSameLevel(-1)
                 guard let match = buffer.lookingAt(buffer.todoLinePattern), let keyword = match[2] else { return nil }

Sources/OrgCore/Parser/Settings.swift +9

	@@ -58,6 +58,15 @@ public struct OrgSettings: Sendable, Equatable {
58	Set(todoSequences.flatMap { ($0.active + $0.done).map(\.name) })	58	Set(todoSequences.flatMap { ($0.active + $0.done).map(\.name) })
59	}	59	}
60		60
		61	/// These settings with TODO keywords from `#+TODO:` syntax (`TODO NEXT \| DONE`); nil when
		62	/// the line has no keywords.
		63	public func withTodoKeywords(_ line: String) -> OrgSettings? {
		64	guard let sequence = SettingsScanner.todoSequence(Substring(line), kind: .sequence) else { return nil }
		65	var copy = self
		66	copy.todoSequences = [sequence]
		67	return copy
		68	}
		69
61	public func isDone(_ name: String) -> Bool {	70	public func isDone(_ name: String) -> Bool {
62	todoSequences.contains { $0.done.contains { $0.name == name } }	71	todoSequences.contains { $0.done.contains { $0.name == name } }
63	}	72	}

Sources/OrgDocument/Buffer.swift +2 −1

 public final class StateBuffer: DocumentBuffer {
     public private(set) var document: DocumentState
     public var selection: [Range<Int>] = [0..<0]
+    public var options: EditingOptions = .org
     public init(_ document: DocumentState) {
         self.document = document
     public func perform(_ command: any OrgCommand, now: Date, answers: [String: String]) -> CommandStep {
         do {
-            let step = try document.run(command, selection: selection, now: now, answers: answers)
+            let step = try document.run(command, selection: selection, now: now, answers: answers, options: options)
             if case .commit(let result) = step, let new = result.selection { selection = new }
             return step
         } catch {

Sources/OrgDocument/DocumentState.swift +2 −2

	@@ -101,11 +101,11 @@ public struct DocumentState: Sendable {
101	/// Runs `command` at `selection` and applies its edits as one undo step.	101	/// Runs `command` at `selection` and applies its edits as one undo step.
102	public mutating func run(	102	public mutating func run(
103	_ command: any OrgCommand, selection: [Range<Int>], now: Date = Date(),	103	_ command: any OrgCommand, selection: [Range<Int>], now: Date = Date(),
104	calendar: Calendar = .current, answers: [String: String] = [:]	104	calendar: Calendar = .current, answers: [String: String] = [:], options: EditingOptions = .org
105	) throws -> CommandStep {	105	) throws -> CommandStep {
106	let context = EditContext(	106	let context = EditContext(
107	revision: revision, text: text, tree: tree, selection: selection,	107	revision: revision, text: text, tree: tree, selection: selection,
108	now: now, calendar: calendar, answers: answers	108	now: now, calendar: calendar, answers: answers, options: options
109	)	109	)
110	let step = command.run(in: context)	110	let step = command.run(in: context)
111	if case .commit(let result) = step, !result.edits.isEmpty {	111	if case .commit(let result) = step, !result.edits.isEmpty {

Sources/OrgEditorAppKit/OrgEditor.swift +3 −1

     }
     public var optionAsMeta: OptionAsMeta = [.left]
+    /// Org options commands follow.
+    public var options: EditingOptions = .org
     private var dispatcher: KeyDispatcher
     /// A region is active: movement extends the selection, as after C-SPC in Emacs.
     private(set) var markActive = false
         return EditContext(
             revision: document.revision, text: document.text, tree: document.tree,
             selection: [selected.location..<NSMaxRange(selected)], now: now, calendar: .current, answers: answers,
-            hidden: hidden.all
+            hidden: hidden.all, options: options
         )
     }

Sources/OrgIndex/FileRecord.swift +11

	@@ -16,6 +16,17 @@ public struct IndexSettings: Sendable, Equatable {
16	public var org: OrgSettings	16	public var org: OrgSettings
17	public var semantic: SemanticSettings	17	public var semantic: SemanticSettings
18		18
		19	/// Settings whose version follows the TODO keywords, so changing them reindexes.
		20	public static func with(todoKeywords org: OrgSettings) -> IndexSettings {
		21	let names = org.todoSequences.map { ($0.active.map(\.name) + ["\|"] + $0.done.map(\.name)).joined(separator: " ") }.joined(separator: ";")
		22	var hash: UInt64 = 0xcbf29ce484222325
		23	for byte in names.utf8 {
		24	hash ^= UInt64(byte)
		25	hash = hash &* 0x100000001b3
		26	}
		27	return IndexSettings(version: 1 + Int(hash % 1_000_000), org: org)
		28	}
		29
19	public init(version: Int = 1, org: OrgSettings = .default, semantic: SemanticSettings = .default) {	30	public init(version: Int = 1, org: OrgSettings = .default, semantic: SemanticSettings = .default) {
20	self.version = version	31	self.version = version
21	self.org = org	32	self.org = org

Sources/Orgstar/ContentView.swift +10 −1

     @AppStorage("keymap") private var preset = KeymapPreset.emacs
     @AppStorage("optionAsMeta") private var optionAsMeta = OptionAsMeta.left.rawValue
     @State private var keymap = KeymapPreset.emacs.keymap
+    @AppStorage("tagsColumn") private var tagsColumn = -77
+    @AppStorage("headingAfterSubtree") private var headingAfterSubtree = true
+    @AppStorage("splitLine") private var splitLine = false
+    @AppStorage("alphabeticalLists") private var alphabeticalLists = true
+    private var options: EditingOptions {
+        Preferences.options(tagsColumn: tagsColumn, headingAfterSubtree: headingAfterSubtree, splitLine: splitLine, alphabeticalLists: alphabeticalLists)
+    }
     @State private var selectedFile: String?
     @State private var query = ""
     @FocusState private var searchFocused: Bool
             .navigationSplitViewColumnWidth(min: 160, ideal: 220, max: 360)
         } detail: {
             if session.path != nil {
-                EditorView(session: session, commands: commands, keymap: keymap, optionAsMeta: OptionAsMeta(rawValue: optionAsMeta), onAppCommand: perform)
+                EditorView(session: session, commands: commands, keymap: keymap, optionAsMeta: OptionAsMeta(rawValue: optionAsMeta), options: options, onAppCommand: perform)
                     .safeAreaInset(edge: .bottom, spacing: 0) { EchoArea(commands: commands) }
             } else {
                 ContentUnavailableView(
             }
         }
         .onChange(of: saveMode, initial: true) { _, mode in session.saveMode = mode }
+        .onChange(of: options, initial: true) { _, options in session.options = options }
         .onChange(of: preset, initial: true) { loadKeymap() }
         .sheet(isPresented: $commands.showingPalette) {
             PaletteView(keymap: keymap) { id in

Sources/Orgstar/EditorView.swift +2

     let commands: AppCommands
     let keymap: Keymap
     let optionAsMeta: OptionAsMeta
+    let options: EditingOptions
     let onAppCommand: (String) -> Void
     final class Coordinator {
         if let editor = coordinator.editor {
             if editor.keymap != keymap { editor.keymap = keymap }
             editor.optionAsMeta = optionAsMeta
+            editor.options = options
         }
         container.window?.isDocumentEdited = session.isDirty
         if let request = session.revealRequest, request.id != coordinator.revealID {

Sources/Orgstar/OrgstarApp.swift +26 −3

 @main
 struct OrgstarApp: App {
     @NSApplicationDelegateAdaptor private var delegate: AppDelegate
-    @State private var workspace = Result { try WorkspaceModel(directory: WorkspaceModel.defaultDirectory) }
+    @State private var workspace = Result {
+        try WorkspaceModel(directory: WorkspaceModel.defaultDirectory, settings: .with(todoKeywords: Preferences.orgSettings))
+    }
     @State private var commands = AppCommands()
-    @State private var session = DocumentSession()
+    @State private var session: DocumentSession = {
+        let session = DocumentSession()
+        session.defaults = Preferences.orgSettings
+        return session
+    }()
     var body: some Scene {
         Window("Orgstar", id: "main") {
     @AppStorage("saveMode") private var saveMode = SaveMode.automatic
     @AppStorage("keymap") private var preset = KeymapPreset.emacs
     @AppStorage("optionAsMeta") private var optionAsMeta = OptionAsMeta.left.rawValue
+    @AppStorage("tagsColumn") private var tagsColumn = -77
+    @AppStorage("headingAfterSubtree") private var headingAfterSubtree = true
+    @AppStorage("splitLine") private var splitLine = false
+    @AppStorage("alphabeticalLists") private var alphabeticalLists = true
+    @AppStorage("todoKeywords") private var todoKeywords = Preferences.defaultTodoKeywords
     var body: some View {
         Form {
                 .font(.caption)
                 .foregroundStyle(.secondary)
                 .textSelection(.enabled)
+            Divider()
+            Picker("Tags:", selection: $tagsColumn) {
+                Text("Aligned to end at column 77").tag(-77)
+                Text("One space after the title").tag(0)
+            }
+            Toggle("M-RET adds the new heading after the subtree", isOn: $headingAfterSubtree)
+            Toggle("M-RET splits the line at the caret", isOn: $splitLine)
+            Toggle("Lists can use letters (a. b. c.)", isOn: $alphabeticalLists)
+            TextField("Default TODO keywords:", text: $todoKeywords)
+            Text("For files without #+TODO, in #+TODO syntax. Takes effect when Orgstar restarts.")
+                .font(.caption)
+                .foregroundStyle(.secondary)
         }
         .padding(20)
-        .frame(width: 420)
+        .frame(width: 480)
     }
 }

Sources/Orgstar/Preferences.swift added +20

@@ -0,0 +1,20 @@
	1	import Foundation
	2	import OrgCore
	3
	4	/// Org preferences, stored in user defaults by the Settings window.
	5	enum Preferences {
	6	static let defaultTodoKeywords = "TODO PROJ LOOP STRT WAIT HOLD IDEA \| DONE KILL"
	7
	8	/// TODO keywords for files without `#+TODO`, read at launch.
	9	static var orgSettings: OrgSettings {
	10	let line = UserDefaults.standard.string(forKey: "todoKeywords") ?? defaultTodoKeywords
	11	return OrgSettings.default.withTodoKeywords(line) ?? .default
	12	}
	13
	14	static func options(tagsColumn: Int, headingAfterSubtree: Bool, splitLine: Bool, alphabeticalLists: Bool) -> EditingOptions {
	15	EditingOptions(
	16	tagsColumn: tagsColumn, insertHeadingRespectContent: headingAfterSubtree,
	17	metaReturnMaySplitLine: splitLine, listAllowAlphabetical: alphabeticalLists
	18	)
	19	}
	20	}

Tests/OrgCoreTests/EmacsOracle.swift +11 −2

     }
 }
+/// The options as Emacs Lisp bindings around `form`.
+func withOptions(_ options: EditingOptions, _ form: String) -> String {
+    func flag(_ value: Bool) -> String { value ? "t" : "nil" }
+    return "(let ((org-tags-column \(options.tagsColumn)) (org-insert-heading-respect-content \(flag(options.insertHeadingRespectContent))) (org-M-RET-may-split-line \(flag(options.metaReturnMaySplitLine))) (org-list-allow-alphabetical \(flag(options.listAllowAlphabetical)))) \(form))"
+}
+/// The options in the user's Doom Emacs.
+let doomOptions = EditingOptions(tagsColumn: 0, insertHeadingRespectContent: true, metaReturnMaySplitLine: false, listAllowAlphabetical: true)
 /// Runs a command the way an editor would: build a context, run, apply the edits.
-func runCommand(_ command: any OrgCommand, _ text: String, caret: Int, answers: [String: String] = [:]) -> (text: String, caret: Int, failure: String?) {
+func runCommand(_ command: any OrgCommand, _ text: String, caret: Int, answers: [String: String] = [:], options: EditingOptions = .org) -> (text: String, caret: Int, failure: String?) {
-    let context = EditContext(revision: 0, text: text, tree: OrgParser.parse(text), selection: [caret..<caret], answers: answers)
+    let context = EditContext(revision: 0, text: text, tree: OrgParser.parse(text), selection: [caret..<caret], answers: answers, options: options)
     switch command.run(in: context) {
     case .commit(let result):
         var new = text

Tests/OrgCoreTests/HeadingCommandTests.swift +8 −3

         try compareWithEmacs(Self.variants.map { ($0, EmacsOracle.positions($0)) }, Self.commands)
     }
+    @Test(.enabled(if: ProcessInfo.processInfo.environment["ORGSTAR_SKIP_ORACLE"] == nil))
+    func headingCommandsMatchEmacsWithDoomOptions() throws {
+        try compareWithEmacs(Self.variants.map { ($0, EmacsOracle.positions($0)) }, Self.commands, options: doomOptions)
+    }
     /// Real headings: `ORGSTAR_ORACLE_CORPUS=<folder>` runs every command on up to 400 heading
     /// lines from the folder's files, with the caret at the line start, the title start and
     /// the line end.
 /// Runs every command at every caret of every input here and in Emacs, and records each
 /// difference in text, caret or failure.
-func compareWithEmacs(_ inputs: [(text: String, carets: [Int])], _ commands: [(command: any OrgCommand, form: String, headingLineOnly: Bool)]) throws {
+func compareWithEmacs(_ inputs: [(text: String, carets: [Int])], _ commands: [(command: any OrgCommand, form: String, headingLineOnly: Bool)], options: EditingOptions = .org) throws {
     try #require(EmacsOracle.isAvailable, "Emacs is required for the oracle tests; set ORGSTAR_SKIP_ORACLE to skip")
     var cases: [EmacsOracle.Case] = []
     var ours: [(label: String, text: String, caret: Int, failed: Bool)] = []
         for offset in carets {
             let onHeadingLine = headingOnLine(at: offset, in: OrgParser.parse(text)) != nil
             for (command, form, headingLineOnly) in commands where onHeadingLine || !headingLineOnly {
-                cases.append(EmacsOracle.Case(text: text, point: EmacsOracle.point(offset, in: text), form: form))
+                cases.append(EmacsOracle.Case(text: text, point: EmacsOracle.point(offset, in: text), form: withOptions(options, form)))
-                let result = runCommand(command, text, caret: offset)
+                let result = runCommand(command, text, caret: offset, options: options)
                 ours.append(("\(command.id) at \(offset) in \(text.debugDescription)", result.text, result.caret, result.failure != nil))
             }
         }

Tests/OrgCoreTests/ListCommandTests.swift +6

         try compareWithEmacs(Self.variants.map { ($0, EmacsOracle.positions($0)) }, Self.commands)
     }
+    @Test(.enabled(if: ProcessInfo.processInfo.environment["ORGSTAR_SKIP_ORACLE"] == nil))
+    func listCommandsMatchEmacsWithDoomOptions() throws {
+        let alphabetical = ["a. x\nb. y\n", "A) one\n   - sub\nB) two\n", "- [@c] x\n- y\n", "1. a\n2. b\n"]
+        try compareWithEmacs((Self.variants + alphabetical).map { ($0, EmacsOracle.positions($0)) }, Self.commands, options: doomOptions)
+    }
     /// Real lists: `ORGSTAR_ORACLE_CORPUS=<folder>` runs every list command in files up to
     /// 20 KB with the caret at the start, bullet end and end of up to six item lines per file.
     @Test(.enabled(if: ProcessInfo.processInfo.environment["ORGSTAR_ORACLE_CORPUS"] != nil))

Tests/OrgCoreTests/StructureCommandTests.swift +5

         try compareWithEmacs(Self.variants.map { ($0, EmacsOracle.positions($0)) }, Self.commands)
     }
+    @Test(.enabled(if: ProcessInfo.processInfo.environment["ORGSTAR_SKIP_ORACLE"] == nil))
+    func structureCommandsMatchEmacsWithDoomOptions() throws {
+        try compareWithEmacs(Self.variants.map { ($0, EmacsOracle.positions($0)) }, Self.commands, options: doomOptions)
+    }
     /// Real files: `ORGSTAR_ORACLE_CORPUS=<folder>` runs every structure command in files up to
     /// 20 KB, with the caret at the start and end of up to eight heading lines per file and on
     /// a body line, for up to 60 files.

docs/plans/2026-10-05-options.md added +33

@@ -0,0 +1,33 @@
	1	# Editing Options Implementation Plan
	2
	3	> For agentic workers: REQUIRED SUB-SKILL: Use superpowers:subagent-driven-development (recommended) or superpowers:executing-plans to implement this plan task-by-task. Steps use checkbox (`- [ ]`) syntax for tracking.
	4
	5	Goal: The org options that change what commands write become settings, so Orgstar can follow the user's Emacs: `org-tags-column`, `org-insert-heading-respect-content`, `org-M-RET-may-split-line`, `org-list-allow-alphabetical`, and the default TODO keywords.
	6
	7	Architecture: `EditingOptions` travels in `EditContext` and `EmacsBuffer`; tag alignment, heading and item insertion, and list bullets read it. Alphabetical lists add `org-list-use-alpha-bul-p` and the alphabetical branches of `org-list-struct-fix-bul`. Default TODO keywords come from a `#+TODO`-syntax line (`OrgSettings.withTodoKeywords`); the index settings version follows them, so changing them reindexes. The app keeps all of it in Settings.
	8
	9	Tech Stack: Swift 6.2 tools, SwiftUI, Swift Testing, Emacs 31.1 / Org 9.8.7 oracle.
	10
	11	Spec: `docs/design.md`, "Commands and keymaps".
	12
	13	## Why
	14
	15	The user's Emacs is Doom, which sets tags column 0, M-RET after the subtree without splitting, alphabetical lists, and the keywords TODO PROJ LOOP STRT WAIT HOLD IDEA \| DONE KILL. Their notes use KILL and have no `#+TODO` lines; 499 of 522 tagged headings end their tags at column 77.
	16
	17	## Defaults chosen (user may change)
	18
	19	- Tags aligned to column 77 (as the files are), not Doom's 0.
	20	- M-RET after the subtree, no splitting, alphabetical lists, and Doom's main keyword sequence, as the user's Emacs does today.
	21
	22	---
	23
	24	### Task 1: Options in commands
	25
	26	- [ ] `EditingOptions`; plumb through every command; alphabetical bullets.
	27	- [ ] Oracle: heading, structure and list suites again under the Doom options (`withOptions` binds the variables around each case), plus alphabetical list variants.
	28	- [ ] Commit "Make org editing options settings".
	29
	30	### Task 2: App
	31
	32	- [ ] Settings section; options to the editor and session; default keywords to documents and the index at launch.
	33	- [ ] Commit "Org options in Settings".

	@@ -11,7 +11,7 @@ extension EmacsBuffer {
11	var structure = saveExcursion { point = start; return listStruct() }	11	var structure = saveExcursion { point = start; return listStruct() }
12	let prevs = structure.prevs	12	let prevs = structure.prevs
13	let description = structure.listType(start, prevs) == .descriptive ? " :: " : nil	13	let description = structure.listType(start, prevs) == .descriptive ? " :: " : nil
14	structure = insertItem(at: pos, structure, prevs, checkbox: checkbox, afterBullet: description)	14	structure = insertItem(at: pos, structure, prevs, checkbox: checkbox, afterBullet: description, splitLine: options.metaReturnMaySplitLine)
15	writeStruct(&structure, structure.parents)	15	writeStruct(&structure, structure.parents)
16	if checkbox { updateCheckboxCount() }	16	if checkbox { updateCheckboxCount() }
17	forwardLine(0)	17	forwardLine(0)
	@@ -91,17 +91,17 @@ extension EmacsBuffer {
91	let upper = marker(lineEnd(point))	91	let upper = marker(lineEnd(point))
92	defer { release(upper) }	92	defer { release(upper) }
93	point = lower	93	point = lower
94	let current = looking(Self.itemPattern).flatMap { match -> String? in	94	let current = looking(itemPattern).flatMap { match -> String? in
95	let box = saveExcursion { () -> [Range<Int>?]? in	95	let box = saveExcursion { () -> [Range<Int>?]? in
96	point = match[0]!.upperBound	96	point = match[0]!.upperBound
97	if let counter = looking("(?:\\[@(?:start:)?[0-9]+\\][ \\t]*)") { point = counter[0]!.upperBound }	97	if let counter = looking(options.listAllowAlphabetical ? "(?:\\[@(?:start:)?([0-9]+\|[A-Za-z])\\][ \\t])" : "(?:\\[@(?:start:)?[0-9]+\\][ \\t])") { point = counter[0]!.upperBound }
98	return looking("(\\[[- X]\\])[ \\t]+")	98	return looking("(\\[[- X]\\])[ \\t]+")
99	}	99	}
100	return box.map { substring($0[1]!.lowerBound, $0[1]!.upperBound) }	100	return box.map { substring($0[1]!.lowerBound, $0[1]!.upperBound) }
101	}	101	}
102	let reference = current == "[X]" ? "[ ]" : "[X]"	102	let reference = current == "[X]" ? "[ ]" : "[X]"
103	point = lower	103	point = lower
104	while point < upper.position, searchForward(Self.itemBeginningPattern, bound: upper.position, move: true) != nil {	104	while point < upper.position, searchForward(itemBeginningPattern, bound: upper.position, move: true) != nil {
105	var structure = listStruct()	105	var structure = listStruct()
106	let old = structure	106	let old = structure
107	let parents = structure.parents	107	let parents = structure.parents
	@@ -302,7 +302,7 @@ public struct InsertCheckboxItem: OrgCommand {
302		302
303	/// An item command that needs point on an item's first line.	303	/// An item command that needs point on an item's first line.
304	private func atItemLine(_ context: EditContext) -> Bool {	304	private func atItemLine(_ context: EditContext) -> Bool {
305	EmacsBuffer(context.text, point: context.caret, settings: context.tree.settings).atItem	305	EmacsBuffer(context.text, point: context.caret, settings: context.tree.settings, options: context.options).atItem
306	}	306	}
307		307
308	/// M-right on an item: `org-indent-item`.	308	/// M-right on an item: `org-indent-item`.

Org editing options !16