feat: add CorrectionEngine (whole-word, longest-first, single pass)

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-10-01 15:09:27 +02:00
parent a5fa0686f0
commit 93bf59e090
2 changed files with 177 additions and 0 deletions
@@ -0,0 +1,79 @@
+import Foundation
+import SstCore
+
+/// Whole-word, case-insensitive, single-pass replacement. Longest match wins, replaced text is never rescanned.
+public struct CorrectionEngine: TextCorrecting {
+    private struct Rule {
+        let source: String
+        let wrote: String
+    }
+
+    private let rules: [Rule]
+    private let regex: NSRegularExpression?
+
+    public init(entries: [DictionaryEntry], knowledge: WordKnowledge) {
+        var seen = Set<String>()
+        var built: [(rule: Rule, order: Int)] = []
+        for (order, entry) in entries.enumerated() {
+            let source = entry.source.trimmingCharacters(in: .whitespacesAndNewlines)
+            let key = EntryKey.key(source)
+            guard !key.isEmpty, !seen.contains(key) else { continue }
+            // A single-word term that is also a real word only biases the model; capitalising it everywhere would corrupt normal text.
+            if case .term(let term) = entry.kind, EntryKey.parts(term).count == 1, knowledge.isWord(term) { continue }
+            seen.insert(key)
+            built.append((Rule(source: source, wrote: entry.wrote), order))
+        }
+        let ordered = built.sorted { a, b in
+            let la = a.rule.source.filter(\.isLetter).count
+            let lb = b.rule.source.filter(\.isLetter).count
+            return la != lb ? la > lb : a.order < b.order
+        }.map(\.rule)
+        rules = ordered
+        if ordered.isEmpty {
+            regex = nil
+        } else {
+            let alternatives = ordered.map { "(\(Self.pattern($0.source)))" }.joined(separator: "|")
+            regex = try? NSRegularExpression(
+                pattern: "(?<![\\p{L}\\p{N}])(?:\(alternatives))(?![\\p{L}\\p{N}])",
+                options: [.caseInsensitive]
+            )
+        }
+    }
+
+    /// Parts joined by "zero or more spaces/hyphens", so "cloud code" also finds "cloudcode" and "Cloud-Code".
+    private static func pattern(_ source: String) -> String {
+        EntryKey.parts(source)
+            .map { NSRegularExpression.escapedPattern(for: $0) }
+            .joined(separator: "[\\s\\-‐‑–]*")
+    }
+
+    public func correct(_ text: String) -> CorrectionResult {
+        guard let regex, !text.isEmpty else { return CorrectionResult(text: text, corrections: []) }
+        let ns = text as NSString
+        var output = ""
+        var outputLength = 0
+        var last = 0
+        var applied: [AppliedCorrection] = []
+
+        for match in regex.matches(in: text, range: NSRange(location: 0, length: ns.length)) {
+            let gap = ns.substring(with: NSRange(location: last, length: match.range.location - last))
+            output += gap
+            outputLength += gap.utf16.count
+
+            let heard = ns.substring(with: match.range)
+            let group = (1..<match.numberOfRanges).first { match.range(at: $0).location != NSNotFound } ?? 1
+            let rule = rules[group - 1]
+
+            output += rule.wrote
+            if heard != rule.wrote {
+                applied.append(AppliedCorrection(
+                    heard: heard, wrote: rule.wrote, rule: rule.source,
+                    start: outputLength, length: rule.wrote.utf16.count))
+            }
+            outputLength += rule.wrote.utf16.count
+            last = match.range.location + match.range.length
+        }
+        output += ns.substring(from: last)
+        return CorrectionResult(text: output, corrections: applied)
+    }
+}