Humanize OpenAI Chat Completions in Swift: An App Store What's New Linter + 5 Free Tools (2026)

// ReleaseLint: draft an App Store "What's New" blurb with OpenAI Chat Completions, or lint one.
//   swiftc -O ReleaseLint.swift -o ReleaseLint
//   ./ReleaseLint --draft "faster cold start, share sheet crash fix, offline drafts"
//   ./ReleaseLint samples/robotic.txt
// Return 0 on clean copy, 1 when a rewrite is needed, 2 when the call or input failed.
// Swift / Foundation only (URLSession). No third-party packages.

import Foundation
#if canImport(FoundationNetworking)
import FoundationNetworking
#endif

struct Problem: Codable {
    let id: String
    let problem: String
}

let maxChars = 280

func die(_ msg: String) -> Never {
    fputs("releaselint: \(msg)\n", stderr)
    exit(2)
}

func fencePattern() -> NSRegularExpression {
    // Build fence opener without a literal triple-backtick string in source.
    let opener = String(repeating: "`", count: 3)
    return try! NSRegularExpression(pattern: "^\\s*" + NSRegularExpression.escapedPattern(for: opener), options: .anchorsMatchLines)
}

let preamble = try! NSRegularExpression(
    pattern: "^\\s*(here('s| is| are)|sure|certainly|of course|gladly)\\b",
    options: .caseInsensitive
)
let filler = try! NSRegularExpression(
    pattern: "\\b(seamless(ly)?|leverage|utilize|rest assured|we're excited to announce|" +
        "please be advised|at this time|going forward|in order to|as an ai|" +
        "delve|elevate|unlock|game[- ]changer|synergy|holistic)\\b",
    options: .caseInsensitive
)
let shouting = try! NSRegularExpression(pattern: "\\b[A-Z]{5,}\\b", options: [])
let label = try! NSRegularExpression(
    pattern: "^\\s*(title|summary|status|update|blurb|what's new)\\s*:",
    options: [.caseInsensitive, .anchorsMatchLines]
)

func lintText(id: String, raw: String) -> [Problem] {
    var p: [Problem] = []
    let t = raw.trimmingCharacters(in: .whitespacesAndNewlines)
    if t.isEmpty {
        return [Problem(id: id, problem: "empty blurb")]
    }
    if t.count > maxChars {
        p.append(Problem(id: id, problem: "blurb is \(t.count) chars (keep it to \(maxChars))"))
    }
    let range = NSRange(t.startIndex..., in: t)
    if preamble.firstMatch(in: t, options: [], range: range) != nil {
        p.append(Problem(id: id, problem: "model preamble (Here is / Sure / Certainly)"))
    }
    if fencePattern().firstMatch(in: t, options: [], range: range) != nil {
        p.append(Problem(id: id, problem: "code fence left in the draft"))
    }
    if label.firstMatch(in: t, options: [], range: range) != nil {
        p.append(Problem(id: id, problem: "pasted Title:/What's New: label"))
    }
    if filler.firstMatch(in: t, options: [], range: range) != nil {
        p.append(Problem(id: id, problem: "robotic filler phrase"))
    }
    if shouting.firstMatch(in: t, options: [], range: range) != nil {
        p.append(Problem(id: id, problem: "shouting (5+ letter capitals)"))
    }
    let bangs = t.filter { $0 == "!" }.count
    if bangs > 1 {
        p.append(Problem(id: id, problem: "stacked exclamation marks (\(bangs))"))
    }
    let emoji = t.unicodeScalars.filter { s in
        let v = s.value
        return (0x1F300...0x1FAFF).contains(v) || (0x2600...0x27BF).contains(v) || (0x1F1E6...0x1F1FF).contains(v)
    }.count
    if emoji > 1 {
        p.append(Problem(id: id, problem: "more than one emoji (\(emoji))"))
    }
    return p
}

func jsonEscape(_ s: String) -> String {
    var b = "\""
    for c in s.unicodeScalars {
        switch c {
        case "\\": b += "\\\\"
        case "\"": b += "\\\""
        case "\n": b += "\\n"
        case "\r": b += "\\r"
        case "\t": b += "\\t"
        default:
            if c.value < 0x20 {
                b += String(format: "\\u%04x", c.value)
            } else {
                b.append(Character(c))
            }
        }
    }
    return b + "\""
}

func extractAssistantContent(_ body: String) -> String? {
    // Minimal walk: find "message" then "content":"..." under choices.
    guard body.range(of: "\"content\"") != nil else { return nil }
    // Prefer the first content after "message"
    var searchFrom = body.startIndex
    if let msg = body.range(of: "\"message\"") {
        searchFrom = msg.upperBound
    }
    guard let key = body.range(of: "\"content\"", range: searchFrom..<body.endIndex) else { return nil }
    guard let colon = body[key.upperBound...].firstIndex(of: ":") else { return nil }
    var i = body.index(after: colon)
    while i < body.endIndex && body[i].isWhitespace { i = body.index(after: i) }
    if i < body.endIndex && body[i] == "n" { // null
        return nil
    }
    guard i < body.endIndex, body[i] == "\"" else { return nil }
    i = body.index(after: i)
    var out = ""
    while i < body.endIndex {
        let c = body[i]
        if c == "\"" { break }
        if c == "\\" {
            let n = body.index(after: i)
            guard n < body.endIndex else { break }
            switch body[n] {
            case "n": out += "\n"; i = body.index(after: n)
            case "r": out += "\r"; i = body.index(after: n)
            case "t": out += "\t"; i = body.index(after: n)
            case "\"": out += "\""; i = body.index(after: n)
            case "\\": out += "\\"; i = body.index(after: n)
            case "u":
                let hStart = body.index(after: n)
                if let hEnd = body.index(hStart, offsetBy: 4, limitedBy: body.endIndex) {
                    let hex = String(body[hStart..<hEnd])
                    if let v = UInt32(hex, radix: 16), let us = UnicodeScalar(v) {
                        out.append(Character(us))
                    }
                    i = hEnd
                } else { out.append(c); i = body.index(after: i) }
            default: out.append(body[n]); i = body.index(after: n)
            }
        } else {
            out.append(c)
            i = body.index(after: i)
        }
    }
    return out
}

func askOpenAI(prompt: String, key: String) -> String {
    let base = (ProcessInfo.processInfo.environment["OPENAI_BASE_URL"] ?? "https://api.openai.com")
        .trimmingCharacters(in: CharacterSet(charactersIn: "/"))
    let model = ProcessInfo.processInfo.environment["OPENAI_MODEL"] ?? "gpt-4o-mini"
    let system = "Write one short App Store What's New blurb from the notes. " +
        "Plain prose only, under \(maxChars) characters. No preamble, no markdown fence, no Title: label."
    let body = "{" +
        "\"model\":\(jsonEscape(model))," +
        "\"max_tokens\":400," +
        "\"messages\":[" +
        "{\"role\":\"system\",\"content\":\(jsonEscape(system))}," +
        "{\"role\":\"user\",\"content\":\(jsonEscape(prompt))}" +
        "]}"

    guard let url = URL(string: base + "/v1/chat/completions") else { die("bad OPENAI_BASE_URL") }
    var req = URLRequest(url: url, timeoutInterval: 60)
    req.httpMethod = "POST"
    req.setValue("application/json", forHTTPHeaderField: "Content-Type")
    req.setValue("Bearer \(key)", forHTTPHeaderField: "Authorization")
    req.httpBody = body.data(using: .utf8)

    final class Box: @unchecked Sendable {
        var data: Data?
        var err: Error?
        var status = 0
    }
    let box = Box()
    let sem = DispatchSemaphore(value: 0)
    URLSession.shared.dataTask(with: req) { data, resp, err in
        box.data = data
        box.err = err
        box.status = (resp as? HTTPURLResponse)?.statusCode ?? 0
        sem.signal()
    }.resume()
    _ = sem.wait(timeout: .now() + 65)

    if let resultErr = box.err { die("request failed: \(resultErr.localizedDescription)") }
    guard let data = box.data, let text = String(data: data, encoding: .utf8) else {
        die("empty reply")
    }
    if box.status / 100 != 2 {
        let snip = String(text.prefix(200))
        die("HTTP \(box.status): \(snip)")
    }
    guard let content = extractAssistantContent(text), !content.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty else {
        die("reply had no assistant content")
    }
    return content
}

func report(_ problems: [Problem], asJson: Bool) {
    if asJson {
        let enc = JSONEncoder()
        if let data = try? enc.encode(problems), let s = String(data: data, encoding: .utf8) {
            print(s)
        } else {
            print("[]")
        }
    } else {
        for p in problems { print("\(p.id): \(p.problem)") }
        if problems.isEmpty { print("ok") }
    }
}

var args = Array(CommandLine.arguments.dropFirst())
let asJson = args.contains("--json")
args.removeAll { $0 == "--json" }
if args.isEmpty { die("usage: --draft \"notes\" | path/to/blurb.txt [--json]") }

let problems: [Problem]
if args[0] == "--draft" {
    let prompt = args.dropFirst().joined(separator: " ").trimmingCharacters(in: .whitespacesAndNewlines)
    if prompt.isEmpty { die("missing draft notes after --draft") }
    guard let key = ProcessInfo.processInfo.environment["OPENAI_API_KEY"], !key.isEmpty else {
        die("set OPENAI_API_KEY")
    }
    let draft = askOpenAI(prompt: prompt, key: key)
    print("--- draft ---")
    print(draft)
    print("-------------")
    problems = lintText(id: "draft", raw: draft)
} else {
    let path = args[0]
    guard FileManager.default.fileExists(atPath: path) else { die("missing file: \(path)") }
    guard let text = try? String(contentsOfFile: path, encoding: .utf8) else {
        die("cannot read \(path)")
    }
    let name = URL(fileURLWithPath: path).lastPathComponent
    problems = lintText(id: name, raw: text)
}
report(problems, asJson: asJson)
exit(problems.isEmpty ? 0 : 1)

#!/usr/bin/env python3
# Fake api.openai.com /v1/chat/completions for tests.
#   python3 mock_openai.py [robotic|clean|error|empty|prose] [port]
import json, sys
from http.server import BaseHTTPRequestHandler, HTTPServer

MODE = sys.argv[1] if len(sys.argv) > 1 else "robotic"
PORT = int(sys.argv[2]) if len(sys.argv) > 2 else 8788
FENCE = "`" * 3
REPLIES = {
    "robotic": (
        "Sure! Here is a What's New blurb:\n"
        + FENCE + "\n"
        "We're excited to announce a seamless onboarding experience. "
        "REST ASSURED we leverage AI to elevate your workflow!!!\n"
        + FENCE
    ),
    "clean": (
        "What's New in 2.4: faster cold-start on iPhone 15, a fix for the "
        "share-sheet crash on iPad, and offline drafts that sync when you're back online."
    ),
    "empty": "",
    "prose": "Certainly, the release notes have been prepared for App Store review.",
}

class Handler(BaseHTTPRequestHandler):
    def do_POST(self):
        length = int(self.headers.get("Content-Length", "0"))
        body = self.rfile.read(length).decode("utf-8")
        try:
            payload = json.loads(body)
        except Exception:
            payload = {}
        auth = self.headers.get("Authorization", "")
        has_bearer = auth.startswith("Bearer ") and len(auth) > 7
        has_model = "\"model\"" in body or "model" in payload
        has_max = "max_tokens" in body or "max_completion_tokens" in body
        has_msgs = "messages" in payload
        print(
            f"path={self.path} auth={'yes' if has_bearer else 'no'} "
            f"model={has_model} max_tokens={has_max} messages={has_msgs}",
            flush=True,
        )
        if MODE == "error":
            status, out = 400, {
                "error": {"message": "invalid model", "type": "invalid_request_error"}
            }
        else:
            text = REPLIES.get(MODE, REPLIES["clean"])
            status, out = 200, {
                "id": "chatcmpl_test",
                "object": "chat.completion",
                "choices": [
                    {
                        "index": 0,
                        "message": {"role": "assistant", "content": text},
                        "finish_reason": "stop",
                    }
                ],
            }
        data = json.dumps(out).encode()
        self.send_response(status)
        self.send_header("Content-Type", "application/json")
        self.send_header("Content-Length", str(len(data)))
        self.end_headers()
        self.wfile.write(data)

    def log_message(self, *args):
        pass

if __name__ == "__main__":
    print(f"mock listening on {PORT} mode={MODE}", flush=True)
    HTTPServer(("127.0.0.1", PORT), Handler).serve_forever()

export PATH=/path/to/swift/usr/bin:$PATH
# On some Linux boxes you also need libncurses.so.6 on LD_LIBRARY_PATH
swiftc -O ReleaseLint.swift -o ReleaseLint

# lint a blurb file
./ReleaseLint samples/clean.txt

# ask OpenAI for a draft, then lint it
export OPENAI_API_KEY=sk-...
./ReleaseLint --draft "faster cold start, share sheet crash fix, offline drafts"

# point it at the mock
python3 mock_openai.py robotic 8788 &
OPENAI_API_KEY=sk-test OPENAI_BASE_URL=http://127.0.0.1:8788 \
  ./ReleaseLint --draft "faster cold start, share sheet crash fix"