Is there any plan for dictionary support

[asmit203]

there is sometimes issues with custom word related to very nearly spoken or specialized words, and it is a problem of the whisper model being not trained on special word but a new dictionary can be maintained for smoother usage exp., is it in the roadmap or planned for future.
if needed I can help in implementing it

[human37]

Hey @asmit203, I think this would be a helpful feature. I'd need to do some digging on what the whisper model supports and the best way to implement this. If you are interested in contributing that is always welcome also. I'll document any work I do on this here for tracking 👍

[TannerRockCode]

Since im out of office here is what I have for Claude Code prompts Ammon. Hope this helps

open-wispr Custom Dictionary — Claude Code Handoff

How to use this file

Run Claude Code from the root of the cloned open-wispr repo:

cd ~/path/to/open-wispr
claude

Then paste the contents of the "PROMPT" section below as your first message.

─────────────────────────────────────────────────────────────────────────────

PROMPT (paste everything from here down)

─────────────────────────────────────────────────────────────────────────────

I need you to integrate a two-layer custom dictionary feature into this project.
Do not ask for clarification — read the source files, make the changes, and confirm when done.

Step 1 — Understand the project

Read the following to orient yourself before touching anything:

• All .swift files under Sources/
• Package.swift (or the .xcodeproj if present)
• ~/.config/open-wispr/config.json (the live config file)

Identify:

1. The function or method that builds and runs the whisper-cli shell command
2. The SwiftUI view that renders the settings panel
3. Where the app loads its config on startup

Step 2 — Create four new Swift source files

Write each file below exactly as specified into the Sources/ directory.

---

Sources/CustomDictionary.swift

import Foundation

struct DictionaryEntry: Codable, Identifiable, Equatable {
    var id: UUID
    var misheard: String
    var correct: String

    init(id: UUID = UUID(), misheard: String, correct: String) {
        self.id = id
        self.misheard = misheard.trimmingCharacters(in: .whitespaces).lowercased()
        self.correct = correct.trimmingCharacters(in: .whitespaces)
    }
}

func levenshtein(_ a: String, _ b: String) -> Int {
    let a = Array(a), b = Array(b)
    let m = a.count, n = b.count
    if m == 0 { return n }
    if n == 0 { return m }
    var dp = Array(repeating: Array(repeating: 0, count: n + 1), count: m + 1)
    for i in 0...m { dp[i][0] = i }
    for j in 0...n { dp[0][j] = j }
    for i in 1...m {
        for j in 1...n {
            if a[i-1] == b[j-1] {
                dp[i][j] = dp[i-1][j-1]
            } else {
                dp[i][j] = 1 + min(dp[i-1][j], dp[i][j-1], dp[i-1][j-1])
            }
        }
    }
    return dp[m][n]
}

struct DictionaryPostProcessor {
    let entries: [DictionaryEntry]
    let fuzzyThreshold: Int

    init(entries: [DictionaryEntry], fuzzyThreshold: Int = 2) {
        self.entries = entries
        self.fuzzyThreshold = fuzzyThreshold
    }

    func apply(to transcript: String) -> String {
        guard !entries.isEmpty else { return transcript }
        var tokens = transcript.components(separatedBy: " ")
        tokens = tokens.map { token -> String in
            let punctuation = token.unicodeScalars.suffix(while: { ".,!?;:\"'".unicodeScalars.contains($0) })
            let punctStr = String(String.UnicodeScalarView(punctuation))
            let word = punctStr.isEmpty ? token : String(token.dropLast(punctStr.count))
            let lowered = word.lowercased()
            for entry in entries {
                if lowered == entry.misheard { return entry.correct + punctStr }
                if levenshtein(lowered, entry.misheard) <= fuzzyThreshold {
                    if abs(word.count - entry.misheard.count) <= fuzzyThreshold {
                        return entry.correct + punctStr
                    }
                }
            }
            return token
        }
        return tokens.joined(separator: " ")
    }

    func buildWhisperPrompt(base: String? = nil) -> String {
        guard !entries.isEmpty else { return base ?? "" }
        let vocab = entries.map { $0.correct }.joined(separator: ", ")
        let vocabHint = "Vocabulary: \(vocab)."
        if let base = base, !base.isEmpty { return "\(base) \(vocabHint)" }
        return vocabHint
    }
}

---

Sources/DictionaryManager.swift

import Foundation

final class DictionaryManager: ObservableObject {
    static let shared = DictionaryManager()

    @Published private(set) var entries: [DictionaryEntry] = []

    private let configURL: URL = {
        FileManager.default.homeDirectoryForCurrentUser
            .appendingPathComponent(".config/open-wispr/config.json")
    }()

    private init() { load() }

    func load() {
        guard let data = try? Data(contentsOf: configURL),
              let raw = try? JSONSerialization.jsonObject(with: data) as? [String: Any],
              let arr = raw["customDictionary"],
              let entriesData = try? JSONSerialization.data(withJSONObject: arr) else { return }
        entries = (try? JSONDecoder().decode([DictionaryEntry].self, from: entriesData)) ?? []
    }

    func save() {
        var raw: [String: Any] = [:]
        if let data = try? Data(contentsOf: configURL),
           let json = try? JSONSerialization.jsonObject(with: data) as? [String: Any] {
            raw = json
        }
        guard let entriesData = try? JSONEncoder().encode(entries),
              let entriesJSON = try? JSONSerialization.jsonObject(with: entriesData) else { return }
        raw["customDictionary"] = entriesJSON
        guard let output = try? JSONSerialization.data(
            withJSONObject: raw, options: [.prettyPrinted, .sortedKeys]) else { return }
        try? output.write(to: configURL, options: .atomic)
    }

    func add(misheard: String, correct: String) {
        let m = misheard.trimmingCharacters(in: .whitespaces).lowercased()
        guard !m.isEmpty, !correct.isEmpty else { return }
        if entries.contains(where: { $0.misheard == m }) { return }
        entries.append(DictionaryEntry(misheard: m, correct: correct.trimmingCharacters(in: .whitespaces)))
        save()
    }

    func update(_ entry: DictionaryEntry, misheard: String, correct: String) {
        guard let idx = entries.firstIndex(of: entry) else { return }
        entries[idx].misheard = misheard.trimmingCharacters(in: .whitespaces).lowercased()
        entries[idx].correct = correct.trimmingCharacters(in: .whitespaces)
        save()
    }

    func remove(at offsets: IndexSet) { entries.remove(atOffsets: offsets); save() }
    func remove(_ entry: DictionaryEntry) { entries.removeAll { $0.id == entry.id }; save() }

    func makeProcessor(fuzzyThreshold: Int = 2) -> DictionaryPostProcessor {
        DictionaryPostProcessor(entries: entries, fuzzyThreshold: fuzzyThreshold)
    }
}

---

Sources/DictionarySettingsView.swift

import SwiftUI

struct DictionarySettingsView: View {
    @ObservedObject private var manager = DictionaryManager.shared
    @State private var newMisheard = ""
    @State private var newCorrect  = ""
    @State private var testInput   = ""
    @State private var testOutput  = ""
    @State private var editingEntry: DictionaryEntry? = nil
    @State private var showDuplicateAlert = false

    var body: some View {
        VStack(alignment: .leading, spacing: 16) {
            VStack(alignment: .leading, spacing: 4) {
                Text("Custom Dictionary").font(.headline)
                Text("Correct words Whisper mishears. Applied at inference (prompt bias) and after transcription (fuzzy substitution).")
                    .font(.caption).foregroundColor(.secondary)
            }
            Divider()
            if manager.entries.isEmpty {
                Text("No entries yet. Add your first word below.")
                    .font(.caption).foregroundColor(.secondary)
                    .frame(maxWidth: .infinity, alignment: .center).padding(.vertical, 8)
            } else {
                List {
                    ForEach(manager.entries) { entry in
                        HStack {
                            if editingEntry?.id == entry.id {
                                InlineEditRow(entry: entry) { editingEntry = nil }
                            } else {
                                VStack(alignment: .leading, spacing: 2) {
                                    Text(entry.misheard)
                                        .font(.system(.body, design: .monospaced))
                                        .foregroundColor(.secondary)
                                    Text("→ \(entry.correct)").font(.body)
                                }
                                Spacer()
                                Button("Edit") { editingEntry = entry }
                                    .buttonStyle(.plain).font(.caption).foregroundColor(.accentColor)
                            }
                        }.padding(.vertical, 2)
                    }
                    .onDelete { manager.remove(at: $0) }
                }
                .frame(minHeight: 120, maxHeight: 240)
                .listStyle(.bordered(alternatesRowBackgrounds: true))
            }
            GroupBox("Add Entry") {
                HStack(spacing: 8) {
                    VStack(alignment: .leading, spacing: 4) {
                        Text("Whisper hears").font(.caption).foregroundColor(.secondary)
                        TextField("e.g. nural", text: $newMisheard).textFieldStyle(.roundedBorder)
                    }
                    Image(systemName: "arrow.right").foregroundColor(.secondary).padding(.top, 16)
                    VStack(alignment: .leading, spacing: 4) {
                        Text("Should be").font(.caption).foregroundColor(.secondary)
                        TextField("e.g. neural", text: $newCorrect).textFieldStyle(.roundedBorder)
                    }
                    Button("Add") {
                        let m = newMisheard.trimmingCharacters(in: .whitespaces)
                        let c = newCorrect.trimmingCharacters(in: .whitespaces)
                        if manager.entries.contains(where: { $0.misheard == m.lowercased() }) {
                            showDuplicateAlert = true
                        } else {
                            manager.add(misheard: m, correct: c)
                            newMisheard = ""; newCorrect = ""
                        }
                    }
                    .disabled(newMisheard.isEmpty || newCorrect.isEmpty).padding(.top, 16)
                }.padding(4)
            }
            GroupBox("Test Substitution") {
                VStack(alignment: .leading, spacing: 6) {
                    TextField("Type a phrase to preview corrections…", text: $testInput)
                        .textFieldStyle(.roundedBorder)
                        .onChange(of: testInput) { testOutput = manager.makeProcessor().apply(to: $0) }
                    if !testOutput.isEmpty && testOutput != testInput {
                        HStack(alignment: .top, spacing: 4) {
                            Image(systemName: "checkmark.circle.fill").foregroundColor(.green).font(.caption)
                            Text(testOutput).font(.body)
                        }
                    } else if !testInput.isEmpty {
                        Text("No substitutions matched.").font(.caption).foregroundColor(.secondary)
                    }
                }.padding(4)
            }
            Spacer()
        }
        .padding()
        .alert("Duplicate Entry", isPresented: $showDuplicateAlert) {
            Button("OK", role: .cancel) {}
        } message: { Text("'\(newMisheard)' is already in the dictionary.") }
    }
}

private struct InlineEditRow: View {
    let entry: DictionaryEntry
    let onDone: () -> Void
    @State private var misheard: String
    @State private var correct: String
    @ObservedObject private var manager = DictionaryManager.shared

    init(entry: DictionaryEntry, onDone: @escaping () -> Void) {
        self.entry = entry; self.onDone = onDone
        _misheard = State(initialValue: entry.misheard)
        _correct  = State(initialValue: entry.correct)
    }

    var body: some View {
        HStack(spacing: 6) {
            TextField("Misheard", text: $misheard)
                .textFieldStyle(.roundedBorder).font(.system(.body, design: .monospaced))
            Image(systemName: "arrow.right").foregroundColor(.secondary)
            TextField("Correct", text: $correct).textFieldStyle(.roundedBorder)
            Button("Save") { manager.update(entry, misheard: misheard, correct: correct); onDone() }
                .disabled(misheard.isEmpty || correct.isEmpty)
            Button("Cancel", role: .cancel) { onDone() }.buttonStyle(.plain).foregroundColor(.secondary)
        }
    }
}

---

Sources/TranscriptionService+Dictionary.swift

import Foundation

extension Process {
    static func dictionaryPromptArguments(existingPrompt: String? = nil) -> [String] {
        let manager = DictionaryManager.shared
        guard !manager.entries.isEmpty else { return [] }
        let prompt = manager.makeProcessor().buildWhisperPrompt(base: existingPrompt)
        return prompt.isEmpty ? [] : ["--prompt", prompt]
    }
}

func applyDictionary(to transcript: String) -> String {
    DictionaryManager.shared.makeProcessor().apply(to: transcript)
}

---

Step 3 — Wire the new code into existing files

After reading the source, make these three targeted edits to the existing codebase:

3a. Transcription function — Layer 1 (prompt injection)
Find the function that builds the whisper-cli argument array.
Append Process.dictionaryPromptArguments(existingPrompt: <whatever existing prompt variable is>)
to the args array before the process is launched.

3b. Transcription function — Layer 2 (post-processing)
Find the line where the raw stdout string from whisper-cli is used (typed at the cursor or returned).
Wrap it: replace rawTranscript (or whatever the variable is named) with
applyDictionary(to: rawTranscript).

3c. Settings UI — add Dictionary tab
Find the settings view. Add DictionarySettingsView() as a new tab or section.
Match whatever tab/section pattern the existing settings already use.

Step 4 — Verify it builds

Run swift build and fix any compile errors. Do not change the logic of the new files —
only fix issues caused by naming mismatches with existing code (e.g. different struct names,
access modifiers, module layout).

Step 5 — Report back

When done, tell me:

• Which existing file and line each of the three wiring changes was applied to
• Whether swift build succeeded
• Any assumptions made due to ambiguities in the source