Recognize the other quoting conventions around paths

Straight single and double quotes were the only pairs treated as a path
boundary, but output quotes paths several other ways: GNU tools use
`like this', markdown-flavored output (and the AI agents that emit it) uses
`like this`, and anything that went through smart-quote substitution uses
the curly pairs.

Replace the "closed by the same character" rule with an opener → closers
map, so an opener pairs only with its own closer and a mismatched pair is
not a boundary.

The new tests use "/tmp/dir.d with prose.txt" and click inside "with": an
unquoted space-joined segment counts only when it carries a "/" or "." of
its own, so that click finds nothing unless a quote pair supplies the
boundary — testUnquotedPathStopsAtProseSegment pins that down. It keeps the
cases honest; a path like "/tmp/my file.txt" would pass them unquoted.

Author: bones7456

Sources/SwiftTerm/Terminal.swift

@@ -7314,26 +7314,39 @@ open class Terminal {
         )
     }
 
-    /// Paths that contain spaces defeat the Ghostty-style regex, but
-    /// shell-quoted output gives an unambiguous boundary: when the lookup
-    /// target sits inside a '...' or "..." pair whose content looks like a
-    /// filesystem path, the whole quoted content (quotes excluded) is the
-    /// link. Innermost wins so "'/a b.png'" resolves to /a b.png.
+    /// Quote pairs that delimit a path in program output, as the opener mapped
+    /// to the closers that can end it. Shells and most tools use the straight
+    /// pairs; GNU tools quote as `like this'; markdown-flavored output (and the
+    /// AI agents that emit it) uses `like this`; anything that has been through
+    /// typographic substitution uses the curly pairs.
+    private static let pathQuoteClosers: [Character: Set<Character>] = [
+        "'": ["'"],
+        "\"": ["\""],
+        "`": ["`", "'"],
+        "\u{2018}": ["\u{2019}"],
+        "\u{201C}": ["\u{201D}"]
+    ]
+
+    /// Paths that contain spaces defeat the Ghostty-style regex, but quoted
+    /// output gives an unambiguous boundary: when the lookup target sits
+    /// inside a quote pair whose content looks like a filesystem path, the
+    /// whole quoted content (quotes excluded) is the link. Innermost wins so
+    /// "'/a b.png'" resolves to /a b.png.
     private func quotedPathMatch(in lineMap: GhosttyImplicitLineMap) -> LinkMatch?
     {
         let chars = Array(lineMap.text)
         var best: LinkMatch?
         var bestLength = Int.max
         for (offset, ch) in chars.enumerated() {
-            guard ch == "'" || ch == "\"" else {
+            guard let closers = Terminal.pathQuoteClosers[ch] else {
                 continue
             }
-            // Treat any quote directly followed by a path-looking prefix as
-            // an opener, closed by the nearest quote of the same kind. This
-            // stays robust against apostrophes in surrounding prose, which
-            // would confuse strict sequential pairing.
+            // Treat any opener directly followed by a path-looking prefix as
+            // the start, closed by the nearest matching closer. This stays
+            // robust against apostrophes in surrounding prose, which would
+            // confuse strict sequential pairing.
             let contentStart = offset + 1
-            guard let contentEnd = (contentStart..<chars.count).first(where: { chars[$0] == ch }) else {
+            guard let contentEnd = (contentStart..<chars.count).first(where: { closers.contains(chars[$0]) }) else {
                 continue
             }
             let length = contentEnd - contentStart

Tests/SwiftTermTests/LinkLookupTests.swift

@@ -247,6 +247,76 @@ final class LinkLookupTests: TerminalDelegate {
         #expect(link == "/tmp/foo.txt")
     }
 
+    // The quote-pair cases below all use "/tmp/dir.d with prose.txt" and click
+    // inside "with". A space-joined segment counts as part of an unquoted path
+    // only when it carries a "/" or "." of its own, so "with" ends the unquoted
+    // match at "/tmp/dir.d" and a full match can only come from the quote pair
+    // — see testUnquotedPathStopsAtProseSegment right below.
+
+    @Test func testUnquotedPathStopsAtProseSegment() {
+        let terminal = Terminal(delegate: self, options: TerminalOptions(cols: 60, rows: 1))
+        terminal.feed(text: "saved /tmp/dir.d with prose.txt ok")
+
+        let link = terminal.link(at: .buffer(Position(col: 20, row: 0)), mode: .explicitAndImplicit)
+        #expect(link == nil)
+    }
+
+    /// GNU tools quote as `like this'.
+    @Test func testGnuStyleQuotedPathWithSpaces() {
+        let terminal = Terminal(delegate: self, options: TerminalOptions(cols: 60, rows: 1))
+        terminal.feed(text: "cannot stat `/tmp/dir.d with prose.txt': No such file")
+
+        let link = terminal.link(at: .buffer(Position(col: 25, row: 0)), mode: .explicitAndImplicit)
+        #expect(link == "/tmp/dir.d with prose.txt")
+    }
+
+    /// Markdown-flavored output (and the AI agents that emit it) uses `like this`.
+    @Test func testBacktickPairQuotedPathWithSpaces() {
+        let terminal = Terminal(delegate: self, options: TerminalOptions(cols: 60, rows: 1))
+        terminal.feed(text: "wrote `/tmp/dir.d with prose.txt` to disk")
+
+        let link = terminal.link(at: .buffer(Position(col: 19, row: 0)), mode: .explicitAndImplicit)
+        #expect(link == "/tmp/dir.d with prose.txt")
+    }
+
+    /// Typographic single quotes, as produced by smart-quote substitution.
+    @Test func testCurlySingleQuotedPathWithSpaces() {
+        let terminal = Terminal(delegate: self, options: TerminalOptions(cols: 60, rows: 1))
+        terminal.feed(text: "saved \u{2018}/tmp/dir.d with prose.txt\u{2019} ok")
+
+        let link = terminal.link(at: .buffer(Position(col: 20, row: 0)), mode: .explicitAndImplicit)
+        #expect(link == "/tmp/dir.d with prose.txt")
+    }
+
+    /// Typographic double quotes.
+    @Test func testCurlyDoubleQuotedPathWithSpaces() {
+        let terminal = Terminal(delegate: self, options: TerminalOptions(cols: 60, rows: 1))
+        terminal.feed(text: "saved \u{201C}/tmp/dir.d with prose.txt\u{201D} ok")
+
+        let link = terminal.link(at: .buffer(Position(col: 20, row: 0)), mode: .explicitAndImplicit)
+        #expect(link == "/tmp/dir.d with prose.txt")
+    }
+
+    /// An opener pairs only with its own closer, so a mismatched pair is not a
+    /// boundary and the spaced path stays undetected.
+    @Test func testMismatchedQuotePairDoesNotMatch() {
+        let terminal = Terminal(delegate: self, options: TerminalOptions(cols: 60, rows: 1))
+        terminal.feed(text: "saved \u{2018}/tmp/dir.d with prose.txt\u{201D} ok")
+
+        let link = terminal.link(at: .buffer(Position(col: 20, row: 0)), mode: .explicitAndImplicit)
+        #expect(link == nil)
+    }
+
+    /// Typographic apostrophes in prose are closers without an opener, so they
+    /// must not start a match of their own.
+    @Test func testCurlyApostropheInProseDoesNotBreakPathDetection() {
+        let terminal = Terminal(delegate: self, options: TerminalOptions(cols: 60, rows: 1))
+        terminal.feed(text: "don\u{2019}t miss '/tmp/dir.d with prose.txt' it\u{2019}s here")
+
+        let link = terminal.link(at: .buffer(Position(col: 24, row: 0)), mode: .explicitAndImplicit)
+        #expect(link == "/tmp/dir.d with prose.txt")
+    }
+
     @Test func testQuotedNonPathDoesNotMatch() {
         let terminal = Terminal(delegate: self, options: TerminalOptions(cols: 30, rows: 1))
         terminal.feed(text: "'hello world'")