Detect quoted file paths with spaces as implicit links

Implicit link detection uses a Ghostty-style regex that stops at spaces
unless the following segment ends in '/' or '.', so a path such as
/Users/me/Screenshot 2026-07-15 at 09.58.24.png is only matched up to
'Screenshot' even when the shell has quoted it unambiguously.

Add a pre-pass over the implicit line map: when the lookup target sits
inside a '...' or "..." pair whose content starts with /, ~/, ./ or ../,
return the whole quoted content (quotes excluded) as the link. Openers
are anchored on a path-looking prefix rather than strict sequential
pairing, so apostrophes in surrounding prose don't confuse it, and the
innermost candidate wins for nested quotes.

The cell-offset mapping is factored out of implicitLinkMatch into
implicitMatch(in:text:startOffset:endOffset:) and shared by both paths,
so hover highlighting and click both see the full quoted range.

Author: bones7456

Sources/SwiftTerm/Terminal.swift

@@ -6074,6 +6074,9 @@ open class Terminal {
         guard let lineMap = buildGhosttyImplicitLineMap(at: position, in: buffer) else {
             return nil
         }
+        if let quoted = quotedPathMatch(in: lineMap) {
+            return quoted
+        }
         guard let regex = Self.ghosttyImplicitLinkRegex else {
             return nil
         }
@@ -6092,65 +6095,126 @@ open class Terminal {
 
             let startOffset = lineMap.text.distance(from: lineMap.text.startIndex, to: textRange.lowerBound)
             let endOffset = lineMap.text.distance(from: lineMap.text.startIndex, to: textRange.upperBound)
-            guard startOffset < lineMap.cells.count else {
-                continue
-            }
-            let boundedEndOffset = min(endOffset, lineMap.cells.count)
-            guard boundedEndOffset > startOffset else {
-                continue
+            if let match = implicitMatch(in: lineMap,
+                                         text: String(lineMap.text[textRange]),
+                                         startOffset: startOffset,
+                                         endOffset: endOffset) {
+                return match
             }
+        }
+        return nil
+    }
+
+    /// Maps a character-offset range in the line map's text back to buffer
+    /// cells, and produces a match when the lookup target falls inside it.
+    private func implicitMatch(in lineMap: GhosttyImplicitLineMap, text: String, startOffset: Int, endOffset: Int) -> LinkMatch?
+    {
+        guard startOffset < lineMap.cells.count else {
+            return nil
+        }
+        let boundedEndOffset = min(endOffset, lineMap.cells.count)
+        guard boundedEndOffset > startOffset else {
+            return nil
+        }
 
-            var containsTarget = false
-            var rowStart: Int?
-            var rowEnd: Int?
-            var rowBounds: [Int: (start: Int, end: Int)] = [:]
-            for idx in startOffset..<boundedEndOffset {
-                let cell = lineMap.cells[idx]
-                let cellEnd = cell.col + max(1, cell.width)
+        var containsTarget = false
+        var rowStart: Int?
+        var rowEnd: Int?
+        var rowBounds: [Int: (start: Int, end: Int)] = [:]
+        for idx in startOffset..<boundedEndOffset {
+            let cell = lineMap.cells[idx]
+            let cellEnd = cell.col + max(1, cell.width)
 
-                if var bounds = rowBounds[cell.row] {
-                    bounds.start = min(bounds.start, cell.col)
-                    bounds.end = max(bounds.end, cellEnd)
-                    rowBounds[cell.row] = bounds
-                } else {
-                    rowBounds[cell.row] = (start: cell.col, end: cellEnd)
+            if var bounds = rowBounds[cell.row] {
+                bounds.start = min(bounds.start, cell.col)
+                bounds.end = max(bounds.end, cellEnd)
+                rowBounds[cell.row] = bounds
+            } else {
+                rowBounds[cell.row] = (start: cell.col, end: cellEnd)
+            }
+
+            if cell.row == lineMap.targetRow {
+                rowStart = min(rowStart ?? cell.col, cell.col)
+                rowEnd = max(rowEnd ?? cellEnd, cellEnd)
+                if lineMap.targetCol >= cell.col && lineMap.targetCol < cellEnd {
+                    containsTarget = true
                 }
+            }
+        }
+        guard containsTarget,
+              let rowStart,
+              let rowEnd,
+              rowStart < rowEnd
+        else {
+            return nil
+        }
 
-                if cell.row == lineMap.targetRow {
-                    rowStart = min(rowStart ?? cell.col, cell.col)
-                    rowEnd = max(rowEnd ?? cellEnd, cellEnd)
-                    if lineMap.targetCol >= cell.col && lineMap.targetCol < cellEnd {
-                        containsTarget = true
-                    }
+        let rowRanges = rowBounds
+            .keys
+            .sorted()
+            .compactMap { row -> LinkMatch.RowRange? in
+                guard let bounds = rowBounds[row], bounds.start < bounds.end else {
+                    return nil
                 }
+                return .init(row: row, range: bounds.start..<bounds.end)
+            }
+
+        return LinkMatch(
+            text: text,
+            row: lineMap.targetRow,
+            range: rowStart..<rowEnd,
+            isExplicit: false,
+            rowRanges: rowRanges
+        )
+    }
+
+    /// 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.
+    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 {
+                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.
+            let contentStart = offset + 1
+            guard let contentEnd = (contentStart..<chars.count).first(where: { chars[$0] == ch }) else {
+                continue
+            }
+            let length = contentEnd - contentStart
+            guard length > 1 && length < bestLength else {
+                continue
             }
-            guard containsTarget,
-                  let rowStart,
-                  let rowEnd,
-                  rowStart < rowEnd
+            let content = String(chars[contentStart..<contentEnd])
+            guard looksLikeQuotedPath(content),
+                  let match = implicitMatch(in: lineMap,
+                                            text: content,
+                                            startOffset: contentStart,
+                                            endOffset: contentEnd)
             else {
                 continue
             }
+            best = match
+            bestLength = length
+        }
+        return best
+    }
 
-            let rowRanges = rowBounds
-                .keys
-                .sorted()
-                .compactMap { row -> LinkMatch.RowRange? in
-                    guard let bounds = rowBounds[row], bounds.start < bounds.end else {
-                        return nil
-                    }
-                    return .init(row: row, range: bounds.start..<bounds.end)
-                }
-
-            return LinkMatch(
-                text: String(lineMap.text[textRange]),
-                row: lineMap.targetRow,
-                range: rowStart..<rowEnd,
-                isExplicit: false,
-                rowRanges: rowRanges
-            )
+    private func looksLikeQuotedPath(_ text: String) -> Bool
+    {
+        if text.hasPrefix("//") {
+            return false
         }
-        return nil
+        return text.hasPrefix("/") || text.hasPrefix("~/") || text.hasPrefix("./") || text.hasPrefix("../")
     }
 
     private func payloadCode(at position: Position, in buffer: Buffer) -> UInt16?

Tests/SwiftTermTests/LinkLookupTests.swift

@@ -121,6 +121,74 @@ final class LinkLookupTests: TerminalDelegate {
         #expect(nextRowLink == nil)
     }
 
+    @Test func testQuotedPathWithSpaces() {
+        let terminal = Terminal(delegate: self, options: TerminalOptions(cols: 60, rows: 1))
+        terminal.feed(text: "'/Users/me/Screenshot 2026-07-15 at 09.58.24.png'")
+
+        let link = terminal.link(at: .buffer(Position(col: 25, row: 0)), mode: .explicitAndImplicit)
+        #expect(link == "/Users/me/Screenshot 2026-07-15 at 09.58.24.png")
+    }
+
+    @Test func testDoubleQuotedPathWithSpaces() {
+        let terminal = Terminal(delegate: self, options: TerminalOptions(cols: 40, rows: 1))
+        terminal.feed(text: "saved to \"/tmp/my file.txt\" ok")
+
+        let link = terminal.link(at: .buffer(Position(col: 16, row: 0)), mode: .explicitAndImplicit)
+        #expect(link == "/tmp/my file.txt")
+    }
+
+    @Test func testQuotedTildePathWithSpaces() {
+        let terminal = Terminal(delegate: self, options: TerminalOptions(cols: 40, rows: 1))
+        terminal.feed(text: "'~/Documents/my notes.md'")
+
+        let link = terminal.link(at: .buffer(Position(col: 5, row: 0)), mode: .explicitAndImplicit)
+        #expect(link == "~/Documents/my notes.md")
+    }
+
+    @Test func testNestedQuotedPathResolvesInnermost() {
+        let terminal = Terminal(delegate: self, options: TerminalOptions(cols: 60, rows: 1))
+        terminal.feed(text: "\"'/Users/me/Screenshot 2026-07-15.png'\"")
+
+        let link = terminal.link(at: .buffer(Position(col: 10, row: 0)), mode: .explicitAndImplicit)
+        #expect(link == "/Users/me/Screenshot 2026-07-15.png")
+    }
+
+    @Test func testQuotedPathAcrossWrappedLines() {
+        let path = "/tmp/dir with space/file.txt"
+        let terminal = Terminal(delegate: self, options: TerminalOptions(cols: 12, rows: 4))
+        terminal.feed(text: "'" + path + "'")
+
+        let topRowLink = terminal.link(at: .buffer(Position(col: 4, row: 0)), mode: .explicitAndImplicit)
+        #expect(topRowLink == path)
+
+        let wrappedRowLink = terminal.link(at: .buffer(Position(col: 3, row: 1)), mode: .explicitAndImplicit)
+        #expect(wrappedRowLink == path)
+    }
+
+    @Test func testQuotedNonPathDoesNotMatch() {
+        let terminal = Terminal(delegate: self, options: TerminalOptions(cols: 30, rows: 1))
+        terminal.feed(text: "'hello world'")
+
+        let link = terminal.link(at: .buffer(Position(col: 4, row: 0)), mode: .explicitAndImplicit)
+        #expect(link == nil)
+    }
+
+    @Test func testApostrophesInProseDoNotBreakPathDetection() {
+        let terminal = Terminal(delegate: self, options: TerminalOptions(cols: 60, rows: 1))
+        terminal.feed(text: "don't miss '/tmp/a b.png' it's here")
+
+        let link = terminal.link(at: .buffer(Position(col: 18, row: 0)), mode: .explicitAndImplicit)
+        #expect(link == "/tmp/a b.png")
+    }
+
+    @Test func testClickOutsideQuotedPathDoesNotMatch() {
+        let terminal = Terminal(delegate: self, options: TerminalOptions(cols: 40, rows: 1))
+        terminal.feed(text: "see '/tmp/a b.png' now")
+
+        let link = terminal.link(at: .buffer(Position(col: 20, row: 0)), mode: .explicitAndImplicit)
+        #expect(link == nil)
+    }
+
     @Test func testImplicitBareDomainDoesNotMatch() {
         let terminal = Terminal(delegate: self, options: TerminalOptions(cols: 30, rows: 1))
         terminal.feed(text: "example.com")