agentix-cli 0.26.0 → 0.28.0

package/apps/mac-voice/Sources/AgentXVoice/ResultCard.swift

@@ -0,0 +1,162 @@
+import AppKit
+import WebKit
+
+/// What the agent said, in a form you can read, click and copy.
+///
+/// Speech is lossy in one specific way that matters: a URL cannot be
+/// spoken usefully, an image cannot be spoken at all, and a name you have
+/// not seen written is a name you cannot act on. The spoken answer is
+/// deliberately short and stripped of exactly those things — so without a
+/// visual surface, everything worth keeping from a turn is the part that
+/// gets thrown away.
+///
+/// Rich content arrives through the same `agentx:ui` directive Telegram
+/// and WhatsApp already use, parsed server-side, so an agent has one way to
+/// attach a link or a picture regardless of where it is speaking.
+final class ResultCard: NSPanel {
+    // A web view, because agents write markdown — headings, bullets,
+    // fenced code, tables. An NSTextView shows that as a mess of asterisks
+    // and hashes, which defeats the card's only purpose: being MORE
+    // readable than the spoken answer, not less.
+    private let web = WKWebView()
+    private let links = NSStackView()
+    private let thumb = NSImageView()
+
+    init() {
+        super.init(contentRect: NSRect(x: 0, y: 0, width: 380, height: 260),
+                   styleMask: [.titled, .closable, .resizable, .utilityWindow, .nonactivatingPanel],
+                   backing: .buffered, defer: false)
+        title = "Agent"
+        // Brand radius on the utility panel so it matches the pill it
+        // sits above rather than defaulting to the system's corner.
+        contentView?.wantsLayer = true
+        isFloatingPanel = true
+        level = .floating
+        hidesOnDeactivate = false
+        collectionBehavior = [.canJoinAllSpaces, .fullScreenAuxiliary]
+
+        let content = NSView(frame: contentRect(forFrameRect: frame))
+        content.autoresizingMask = [.width, .height]
+
+        // Selectable, so the whole point — copying a link or a name out —
+        // actually works. Editable would let a stray keystroke destroy the
+        // answer before it is read.
+        web.setValue(false, forKey: "drawsBackground")
+        web.navigationDelegate = self
+        web.autoresizingMask = [.width, .height]
+        content.addSubview(web)
+
+        thumb.imageScaling = .scaleProportionallyUpOrDown
+        thumb.isHidden = true
+        content.addSubview(thumb)
+
+        links.orientation = .horizontal
+        links.spacing = 8
+        links.edgeInsets = NSEdgeInsets(top: 6, left: 10, bottom: 6, right: 10)
+        content.addSubview(links)
+
+        contentView = content
+        layout(content)
+    }
+
+    private func layout(_ content: NSView) {
+        let w = content.bounds.width, h = content.bounds.height
+        let linkH: CGFloat = links.arrangedSubviews.isEmpty ? 0 : 34
+        let imgH: CGFloat = thumb.isHidden ? 0 : 120
+        thumb.frame = NSRect(x: 10, y: h - imgH - 10, width: w - 20, height: imgH)
+        web.frame = NSRect(x: 0, y: linkH, width: w, height: h - linkH - imgH - (imgH > 0 ? 16 : 0))
+        links.frame = NSRect(x: 0, y: 0, width: w, height: linkH)
+    }
+
+    /// Does this turn have anything the spoken answer did not already
+    /// deliver?
+    ///
+    /// The card opened on every turn, including "Ok." — a window with one
+    /// word in it, appearing and demanding dismissal, for an answer you had
+    /// already heard. A surface that adds nothing is worse than no surface:
+    /// it trains you to ignore it, so the turn where it DOES carry a link
+    /// gets ignored too.
+    ///
+    /// Worth showing when there is rich content, a URL you could click, or
+    /// materially more written than was spoken. Otherwise the speech was
+    /// the whole answer.
+    static func isWorthShowing(spoken: String, written: String?, buttons: [(String, String)], imageURL: String?) -> Bool {
+        if !buttons.isEmpty || imageURL != nil { return true }
+        let text = (written?.isEmpty == false ? written! : spoken)
+        if text.range(of: #"https?://"#, options: .regularExpression) != nil { return true }
+        // Speech drops formatting, so written is often a little longer for
+        // the same content. Only a real difference counts.
+        let spokenLen = spoken.trimmingCharacters(in: .whitespacesAndNewlines).count
+        let writtenLen = text.trimmingCharacters(in: .whitespacesAndNewlines).count
+        if writtenLen > spokenLen + 80 { return true }
+        // Long enough that re-reading it beats re-hearing it.
+        return writtenLen > 280
+    }
+
+    /// `spoken` is what was said; `written` is the fuller answer with the
+    /// URLs and formatting the spoken form had to drop.
+    @MainActor
+    func show(spoken: String, written: String?, buttons: [(String, String)], imageURL: String?) {
+        let source = (written?.isEmpty == false ? written! : spoken)
+        web.loadHTMLString(Markdown.page(Markdown.toHTML(source), css: Brand.cardCSS), baseURL: nil)
+
+        links.arrangedSubviews.forEach { links.removeArrangedSubview($0); $0.removeFromSuperview() }
+        for (label, url) in buttons.prefix(4) {
+            let b = NSButton(title: label, target: self, action: #selector(openLink(_:)))
+            b.bezelStyle = .rounded
+            b.toolTip = url
+            b.identifier = NSUserInterfaceItemIdentifier(url)
+            links.addArrangedSubview(b)
+        }
+
+        thumb.isHidden = true
+        if let s = imageURL, let u = URL(string: s) {
+            // Off the main thread: a slow image must never stall the UI,
+            // and the card is useful without it.
+            URLSession.shared.dataTask(with: u) { [weak self] data, _, _ in
+                guard let data, let img = NSImage(data: data) else { return }
+                Task { @MainActor in
+                    guard let self else { return }
+                    self.thumb.image = img
+                    self.thumb.isHidden = false
+                    if let c = self.contentView { self.layout(c) }
+                }
+            }.resume()
+        }
+
+        if let c = contentView { layout(c) }
+        positionAboveWidget()
+        orderFrontRegardless()
+    }
+
+    @objc private func openLink(_ sender: NSButton) {
+        guard let s = sender.identifier?.rawValue, let u = URL(string: s) else { return }
+        NSWorkspace.shared.open(u)
+    }
+
+    /// Sits just above the pill so the two read as one thing.
+    private func positionAboveWidget() {
+        guard let screen = NSScreen.main else { return }
+        let v = screen.visibleFrame
+        setFrameOrigin(NSPoint(x: v.maxX - frame.width - 24, y: v.minY + 24 + 54 + 10))
+    }
+
+    override var canBecomeKey: Bool { true }
+}
+
+extension ResultCard: WKNavigationDelegate {
+    /// Links open in the real browser. A 380-point utility panel is not a
+    /// place to read a web page, and navigating away would replace the
+    /// answer the card exists to hold.
+    func webView(_ webView: WKWebView,
+                 decidePolicyFor navigationAction: WKNavigationAction,
+                 decisionHandler: @escaping (WKNavigationActionPolicy) -> Void) {
+        if navigationAction.navigationType == .linkActivated,
+           let url = navigationAction.request.url {
+            NSWorkspace.shared.open(url)
+            decisionHandler(.cancel)
+            return
+        }
+        decisionHandler(.allow)
+    }
+}

package/apps/mac-voice/Sources/AgentXVoice/SmartPaste.swift

@@ -0,0 +1,72 @@
+import AppKit
+
+/// ⌘⌥V — paste the clipboard in the shape the destination wants.
+///
+/// The decision, the transforms and the safety checks all live in agentx
+/// (`agentx paste`), not here. Same split as pointing and looking: Swift
+/// owns the hotkey and the panel, and the capability itself belongs to
+/// every agent rather than to this one app. The widget is a trigger.
+///
+/// Resolved through a LOGIN SHELL rather than an absolute path. A GUI app
+/// launched from Finder inherits almost no environment, so a hardcoded
+/// path is the difference between working from a terminal and failing
+/// mysteriously on double-click — and the path would differ per machine
+/// anyway. `AGENTX_PASTE_COMMAND` overrides it.
+enum SmartPaste {
+
+    struct Result {
+        let applied: String
+        let reason: String
+        let changed: Bool
+    }
+
+    /// Runs off the main thread: a login shell costs ~100ms to start, and
+    /// blocking the main thread would freeze the panel mid-keystroke.
+    static func run(completion: @escaping (Result?) -> Void) {
+        DispatchQueue.global(qos: .userInitiated).async {
+            let result = execute()
+            DispatchQueue.main.async { completion(result) }
+        }
+    }
+
+    private static func execute() -> Result? {
+        let process = Process()
+        process.executableURL = URL(fileURLWithPath: "/bin/zsh")
+        // -l so PATH includes the places node and the CLI actually live.
+        process.arguments = ["-lc", Config.pasteCommand + " --json"]
+
+        let pipe = Pipe()
+        process.standardOutput = pipe
+        process.standardError = Pipe()
+
+        do {
+            try process.run()
+        } catch {
+            Log.info("smart paste: could not start (\(error.localizedDescription))")
+            return nil
+        }
+
+        // Read before waiting: a full pipe buffer with nobody draining it
+        // deadlocks the child, and this one prints the whole clipboard.
+        let data = pipe.fileHandleForReading.readDataToEndOfFile()
+        process.waitUntilExit()
+
+        guard let object = try? JSONSerialization.jsonObject(with: data) as? [String: Any] else {
+            Log.info("smart paste: no JSON from `\(Config.pasteCommand)`")
+            return nil
+        }
+        return Result(
+            applied: object["applied"] as? String ?? "asIs",
+            reason: object["reason"] as? String ?? "",
+            changed: object["changed"] as? Bool ?? false,
+        )
+    }
+
+    /// What to show after a paste. Deliberately quiet when nothing changed:
+    /// the common case is "pasted as copied", and announcing that every
+    /// time would make the feature feel like it is in the way.
+    static func summary(_ result: Result) -> String? {
+        guard result.changed else { return nil }
+        return result.applied
+    }
+}

package/apps/mac-voice/Sources/AgentXVoice/Speech.swift

@@ -0,0 +1,192 @@
+import AVFoundation
+import Foundation
+
+/// Speech in and out, ElevenLabs first with a local fallback on each side.
+///
+/// The fallbacks are not decoration. This widget is push-to-talk on a
+/// laptop: it will be used on hotel wifi, on a plane, and on the day the
+/// key expires. A voice assistant that answers "network error" out loud is
+/// worse than one that answers in a robot voice, so STT degrades to
+/// on-device mlx-whisper and TTS degrades to `say`.
+enum Speech {
+    // MARK: Speech to text
+
+    static func transcribe(wav: Data) async throws -> String {
+        if let key = Config.elevenLabsKey {
+            do { return try await elevenLabsSTT(wav: wav, key: key) }
+            catch { Log.warn("ElevenLabs STT failed (\(error.localizedDescription)); falling back to mlx-whisper") }
+        }
+        return try await mlxWhisper(wav: wav)
+    }
+
+    private static func elevenLabsSTT(wav: Data, key: String) async throws -> String {
+        var req = URLRequest(url: URL(string: "https://api.elevenlabs.io/v1/speech-to-text")!)
+        req.httpMethod = "POST"
+        req.timeoutInterval = 60
+        req.setValue(key, forHTTPHeaderField: "xi-api-key")
+
+        let boundary = "agentx-\(UUID().uuidString)"
+        req.setValue("multipart/form-data; boundary=\(boundary)", forHTTPHeaderField: "Content-Type")
+        var body = Data()
+        func field(_ name: String, _ value: String) {
+            body.append("--\(boundary)\r\nContent-Disposition: form-data; name=\"\(name)\"\r\n\r\n\(value)\r\n".data(using: .utf8)!)
+        }
+        field("model_id", Config.sttModel)
+        body.append("--\(boundary)\r\nContent-Disposition: form-data; name=\"file\"; filename=\"speech.wav\"\r\nContent-Type: audio/wav\r\n\r\n".data(using: .utf8)!)
+        body.append(wav)
+        body.append("\r\n--\(boundary)--\r\n".data(using: .utf8)!)
+        req.httpBody = body
+
+        let (data, response) = try await URLSession.shared.data(for: req)
+        try check(response, data, "speech-to-text")
+        struct Reply: Decodable { let text: String? }
+        guard let text = (try? JSONDecoder().decode(Reply.self, from: data))?.text else {
+            throw VoiceError.api("speech-to-text returned no text")
+        }
+        return text.trimmingCharacters(in: .whitespacesAndNewlines)
+    }
+
+    /// On-device fallback. Writes the WAV to a temp file because
+    /// mlx_whisper is a CLI that takes a path.
+    private static func mlxWhisper(wav: Data) async throws -> String {
+        guard FileManager.default.isExecutableFile(atPath: Config.mlxWhisper) else {
+            throw VoiceError.api("no ElevenLabs key and mlx_whisper not found at \(Config.mlxWhisper)")
+        }
+        let dir = URL(fileURLWithPath: NSTemporaryDirectory())
+        let audio = dir.appendingPathComponent("agentx-voice-\(UUID().uuidString).wav")
+        try wav.write(to: audio)
+        defer { try? FileManager.default.removeItem(at: audio) }
+
+        let out = try run(Config.mlxWhisper,
+                          ["--model", Config.mlxModel, "--output-format", "txt",
+                           "--output-dir", dir.path, audio.path])
+        // mlx_whisper writes <name>.txt next to the audio; prefer that over
+        // stdout, which also carries progress noise.
+        let txt = audio.deletingPathExtension().appendingPathExtension("txt")
+        defer { try? FileManager.default.removeItem(at: txt) }
+        if let s = try? String(contentsOf: txt, encoding: .utf8) {
+            return s.trimmingCharacters(in: .whitespacesAndNewlines)
+        }
+        return out.trimmingCharacters(in: .whitespacesAndNewlines)
+    }
+
+    // MARK: Text to speech
+
+    static func speak(_ text: String) async {
+        guard !text.isEmpty else { return }
+        if let key = Config.elevenLabsKey {
+            do {
+                let mp3 = try await elevenLabsTTS(text: text, key: key)
+                try await Player.shared.play(mp3)
+                return
+            } catch {
+                Log.warn("ElevenLabs TTS failed (\(error.localizedDescription)); falling back to say")
+            }
+        }
+        _ = try? run("/usr/bin/say", [text])
+    }
+
+    private static func elevenLabsTTS(text: String, key: String) async throws -> Data {
+        let url = URL(string: "https://api.elevenlabs.io/v1/text-to-speech/\(Config.voiceID)")!
+        var req = URLRequest(url: url)
+        req.httpMethod = "POST"
+        req.timeoutInterval = 60
+        req.setValue(key, forHTTPHeaderField: "xi-api-key")
+        req.setValue("application/json", forHTTPHeaderField: "Content-Type")
+        req.httpBody = try JSONSerialization.data(withJSONObject: [
+            "text": text,
+            "model_id": Config.ttsModel,
+            "voice_settings": ["stability": 0.5, "similarity_boost": 0.75],
+        ])
+        let (data, response) = try await URLSession.shared.data(for: req)
+        try check(response, data, "text-to-speech")
+        return data
+    }
+
+    // MARK: Helpers
+
+    private static func check(_ response: URLResponse, _ data: Data, _ what: String) throws {
+        guard let http = response as? HTTPURLResponse else { return }
+        guard (200..<300).contains(http.statusCode) else {
+            let detail = String(data: data.prefix(300), encoding: .utf8) ?? ""
+            throw VoiceError.api("\(what) HTTP \(http.statusCode): \(detail)")
+        }
+    }
+
+    @discardableResult
+    static func run(_ path: String, _ args: [String]) throws -> String {
+        let p = Process()
+        p.executableURL = URL(fileURLWithPath: path)
+        p.arguments = args
+        let pipe = Pipe()
+        p.standardOutput = pipe
+        p.standardError = Pipe()
+        try p.run()
+        let data = pipe.fileHandleForReading.readDataToEndOfFile()
+        p.waitUntilExit()
+        return String(data: data, encoding: .utf8) ?? ""
+    }
+}
+
+enum VoiceError: LocalizedError {
+    case api(String)
+    var errorDescription: String? { if case .api(let m) = self { return m }; return nil }
+}
+
+/// Holds a strong reference to the player for the life of playback —
+/// an AVAudioPlayer that goes out of scope stops mid-sentence.
+final class Player: NSObject, AVAudioPlayerDelegate {
+    static let shared = Player()
+    private var player: AVAudioPlayer?
+    private var finished: CheckedContinuation<Void, Never>?
+
+    func play(_ mp3: Data) async throws {
+        let p = try AVAudioPlayer(data: mp3)
+        p.delegate = self
+        player = p
+        p.play()
+        await withCheckedContinuation { (c: CheckedContinuation<Void, Never>) in
+            finished = c
+        }
+    }
+
+    func audioPlayerDidFinishPlaying(_ player: AVAudioPlayer, successfully flag: Bool) {
+        finished?.resume(); finished = nil; self.player = nil
+    }
+}
+
+/// Logs to stderr AND to a file.
+///
+/// The app is normally launched with `open`, which sends stderr nowhere.
+/// The first crash left a .ips report and no application log at all, so
+/// the cause had to be reconstructed from a stack trace. A few lines of
+/// file logging is the difference between reading what happened and
+/// inferring it.
+enum Log {
+    private static let queue = DispatchQueue(label: "tn.acme.agentx.voice.log")
+    private static let path = "\(NSHomeDirectory())/Library/Logs/agentx-voice.log"
+
+    static func warn(_ s: String) { write("WARN \(s)") }
+    static func info(_ s: String) { write("INFO \(s)") }
+
+    private static func write(_ s: String) {
+        let line = "[\(stamp())] \(s)\n"
+        FileHandle.standardError.write(line.data(using: .utf8)!)
+        queue.async {
+            guard let data = line.data(using: .utf8) else { return }
+            if let fh = FileHandle(forWritingAtPath: path) {
+                defer { try? fh.close() }
+                _ = try? fh.seekToEnd()
+                try? fh.write(contentsOf: data)
+            } else {
+                try? data.write(to: URL(fileURLWithPath: path))
+            }
+        }
+    }
+
+    private static func stamp() -> String {
+        let f = DateFormatter()
+        f.dateFormat = "HH:mm:ss"
+        return f.string(from: Date())
+    }
+}

package/apps/mac-voice/Sources/AgentXVoice/StepLabel.swift

@@ -0,0 +1,159 @@
+import Foundation
+
+/// Turning a tool name into something a person would say.
+///
+/// The marquee was rendering the raw identifier off the event bus, so a
+/// panel meant to tell you what the assistant is doing said:
+///
+///     mcp__agentx__agentx_task · 68s
+///
+/// Nobody outside this codebase can read that, and it is on screen during
+/// the exact moments the widget exists for — the long waits when you want
+/// to know whether anything is happening.
+///
+/// Deterministic on purpose. There is a decision seat that chooses what to
+/// SAY out loud (seats/voice-narration.ts) and it earns its call, because
+/// picking which steps are worth interrupting for is a judgement. This is
+/// not that. Steps arrive several times a second, the mapping from tool to
+/// verb is fixed, and a model in this path would add latency and cost to a
+/// lookup table.
+///
+/// Two rules, from watching real steps go past:
+///   - lead with the VERB, because the label is read at a glance and the
+///     first word is the only one guaranteed to be seen before it scrolls
+///   - carry a detail when there is a useful one, but show the file's name
+///     rather than its full path — the last component is the part that
+///     identifies it, and the leading directories eat the whole label
+enum StepLabel {
+
+    /// Plain-language verb per tool. Present tense, no jargon, no tool names.
+    private static let verbs: [String: String] = [
+        "Bash": "Running a command",
+        "Read": "Reading",
+        "Edit": "Editing",
+        "Write": "Writing",
+        "NotebookEdit": "Editing a notebook",
+        "Glob": "Looking for files",
+        "Grep": "Searching the code",
+        "WebSearch": "Searching the web",
+        "WebFetch": "Reading a web page",
+        "TodoWrite": "Updating the plan",
+        "Task": "Handing work to a helper",
+        "Agent": "Handing work to a helper",
+        "Skill": "Using a skill",
+        "ToolSearch": "Finding the right tool",
+        "SendMessage": "Messaging another agent",
+        "ListAgents": "Checking who is available",
+        "ScheduleWakeup": "Scheduling a follow-up",
+        "Monitor": "Watching for something to finish",
+        "TaskOutput": "Checking on background work",
+        "TaskList": "Checking on background work",
+        "KillShell": "Stopping a command",
+        "BashOutput": "Checking a command's output",
+    ]
+
+    /// agentx's own MCP tools, keyed by the bare name after the prefixes.
+    private static let agentxVerbs: [String: String] = [
+        "task": "Handing work to another agent",
+        "send": "Sending a message",
+        "send_agent": "Messaging another agent",
+        "send_contact": "Sending a message",
+        "channel_reply": "Replying on the channel",
+        "channel_label": "Labelling the conversation",
+        "recent": "Reading recent messages",
+        "agents": "Checking who is available",
+        "health": "Checking the system",
+        "crons": "Checking scheduled jobs",
+        "debug": "Checking the logs",
+        "inspect": "Inspecting the setup",
+        "generate": "Generating something",
+        "skill_match": "Finding a matching skill",
+        "wiki_query": "Searching the wiki",
+        "wiki_patch": "Updating the wiki",
+        "wiki_interview": "Working through the wiki",
+        "graph_review": "Reviewing the activity graph",
+        "attach_next": "Picking up an attachment",
+        "attach_answer": "Answering an attachment",
+        "detect_output_type": "Working out the reply format",
+    ]
+
+    /// A person-facing phrase for a tool call, or nil when the step is not
+    /// worth putting on screen.
+    static func describe(tool: String, detail: String?) -> String? {
+        guard !tool.isEmpty, tool != "tool_use" else { return nil }
+
+        let verb = verbFor(tool)
+        guard let detail, !detail.isEmpty else { return verb }
+
+        // A skill reads better named than appended: "Using the gitlab
+        // skill", not "Using a skill: gitlab".
+        if tool == "Skill" {
+            let name = shorten(detail, for: tool)
+            if !name.isEmpty { return "Using the \(name) skill" }
+        }
+
+        // A detail only helps when it is short enough to read while it
+        // scrolls past. Long ones are the whole point of the marquee, so
+        // they stay — but they are cleaned up first.
+        let shown = shorten(detail, for: tool)
+        return shown.isEmpty ? verb : "\(verb): \(shown)"
+    }
+
+    private static func verbFor(_ tool: String) -> String {
+        if let known = verbs[tool] { return known }
+
+        // mcp__<server>__<name>. The server prefix is an implementation
+        // detail; the name is the only part with meaning in it.
+        if tool.hasPrefix("mcp__") {
+            let parts = tool.dropFirst(5).components(separatedBy: "__")
+            let server = parts.first ?? ""
+            var name = parts.count > 1 ? parts[1...].joined(separator: " ") : (parts.first ?? tool)
+            // agentx's tools are all named agentx_<verb>; the repetition
+            // carries nothing.
+            if name.hasPrefix("agentx_") { name = String(name.dropFirst("agentx_".count)) }
+            if server == "agentx", let known = agentxVerbs[name] { return known }
+            // For an unmapped MCP tool the NAME is the action and the
+            // server is packaging. "Search files" tells you what is
+            // happening; "Using Claude ai google drive" does not.
+            return humanWords(name.isEmpty ? server : name)
+        }
+
+        // Something we have no phrase for. Spacing out the camel case is a
+        // better guess than the identifier, and is self-correcting: a tool
+        // nobody mapped reads as "Running Some Tool" rather than as code.
+        return humanWords(tool)
+    }
+
+    /// `file_path` style values are long and front-loaded with directories
+    /// nobody is reading. The basename identifies the file.
+    private static func shorten(_ detail: String, for tool: String) -> String {
+        var text = detail
+            .replacingOccurrences(of: "\n", with: " ")
+            .trimmingCharacters(in: .whitespaces)
+
+        if ["Read", "Edit", "Write", "NotebookEdit"].contains(tool), text.contains("/") {
+            text = (text as NSString).lastPathComponent
+        }
+        // Collapse runs of whitespace left by flattened multi-line commands.
+        while text.contains("  ") { text = text.replacingOccurrences(of: "  ", with: " ") }
+        return text
+    }
+
+    /// "agentx_send_agent" / "SomeToolName" -> "Some Tool Name".
+    private static func humanWords(_ raw: String) -> String {
+        let spaced = raw
+            .replacingOccurrences(of: "_", with: " ")
+            .replacingOccurrences(of: "-", with: " ")
+        var out = ""
+        var previousWasLower = false
+        for ch in spaced {
+            if ch.isUppercase && previousWasLower { out.append(" ") }
+            out.append(ch)
+            previousWasLower = ch.isLowercase || ch.isNumber
+        }
+        let words = out.split(separator: " ").map(String.init)
+        guard let first = words.first else { return raw }
+        return ([first.prefix(1).uppercased() + first.dropFirst()]
+            + words.dropFirst().map { $0.lowercased() }).joined(separator: " ")
+    }
+}