+305

backend/src/ask.zig

··· 1 1 + //! Knowledge synthesis endpoint - answers questions using corpus context. 2 2 + //! 3 3 + //! Takes a question, retrieves relevant documents via FTS search, 4 4 + //! sends them to Claude for synthesis, returns answer with citations. 5 5 + 6 6 + const std = @import("std"); 7 7 + const http = std.http; 8 8 + const json = std.json; 9 9 + const mem = std.mem; 10 10 + const posix = std.posix; 11 11 + const Allocator = mem.Allocator; 12 12 + const logfire = @import("logfire"); 13 13 + const db = @import("db/mod.zig"); 14 14 + const search = @import("search.zig"); 15 15 + 16 16 + const MAX_CONTEXT_DOCS = 10; 17 17 + const MAX_CONTENT_CHARS = 4000; // per doc, ~1000 tokens 18 18 + const CLAUDE_MODEL = "claude-sonnet-4-20250514"; 19 19 + 20 20 + /// Source document included in the answer 21 21 + const Source = struct { 22 22 + uri: []const u8, 23 23 + title: []const u8, 24 24 + url: []const u8, 25 25 + }; 26 26 + 27 27 + /// Response from the /ask endpoint 28 28 + const AskResponse = struct { 29 29 + answer: []const u8, 30 30 + sources: []const Source, 31 31 + }; 32 32 + 33 33 + /// Document with full content for context 34 34 + const ContextDoc = struct { 35 35 + uri: []const u8, 36 36 + title: []const u8, 37 37 + content: []const u8, 38 38 + base_path: []const u8, 39 39 + path: []const u8, 40 40 + platform: []const u8, 41 41 + 42 42 + fn buildUrl(self: ContextDoc, alloc: Allocator) ![]const u8 { 43 43 + if (self.base_path.len == 0) return ""; 44 44 + // base_path is like "https://foo.leaflet.pub", path is like "/001" 45 45 + const url = try std.fmt.allocPrint(alloc, "{s}{s}", .{ self.base_path, self.path }); 46 46 + return url; 47 47 + } 48 48 + }; 49 49 + 50 50 + /// Answer a question using corpus knowledge 51 51 + pub fn ask(alloc: Allocator, question: []const u8) ![]const u8 { 52 52 + const span = logfire.span("ask.synthesize", .{ .question = question }); 53 53 + defer span.end(); 54 54 + 55 55 + const api_key = posix.getenv("ANTHROPIC_API_KEY") orelse { 56 56 + return try serializeError(alloc, "ANTHROPIC_API_KEY not configured"); 57 57 + }; 58 58 + 59 59 + // 1. search for relevant docs 60 60 + const docs = try getContextDocs(alloc, question); 61 61 + if (docs.len == 0) { 62 62 + return try serializeError(alloc, "no relevant documents found"); 63 63 + } 64 64 + 65 65 + // 2. build prompt with context 66 66 + const prompt = try buildPrompt(alloc, question, docs); 67 67 + defer alloc.free(prompt); 68 68 + 69 69 + // 3. call Claude 70 70 + const answer = try callClaude(alloc, api_key, prompt) orelse { 71 71 + return try serializeError(alloc, "failed to get response from Claude"); 72 72 + }; 73 73 + defer alloc.free(answer); 74 74 + 75 75 + // 4. build response with sources 76 76 + return try serializeResponse(alloc, answer, docs); 77 77 + } 78 78 + 79 79 + fn getContextDocs(alloc: Allocator, question: []const u8) ![]ContextDoc { 80 80 + const client = db.getClient() orelse return error.NotInitialized; 81 81 + 82 82 + // build FTS query from question 83 83 + const fts_query = try search.buildFtsQuery(alloc, question); 84 84 + defer if (fts_query.len > 0) alloc.free(fts_query); 85 85 + 86 86 + if (fts_query.len == 0) return &.{}; 87 87 + 88 88 + // query for docs with full content 89 89 + var result = client.query( 90 90 + \\SELECT uri, title, content, base_path, COALESCE(path, '') as path, platform 91 91 + \\FROM documents 92 92 + \\WHERE uri IN ( 93 93 + \\ SELECT uri FROM documents_fts 94 94 + \\ WHERE documents_fts MATCH ? 95 95 + \\ ORDER BY rank LIMIT ? 96 96 + \\) 97 97 + , &.{ fts_query, std.fmt.comptimePrint("{}", .{MAX_CONTEXT_DOCS}) }) catch { 98 98 + return &.{}; 99 99 + }; 100 100 + defer result.deinit(); 101 101 + 102 102 + var docs: std.ArrayList(ContextDoc) = .empty; 103 103 + errdefer docs.deinit(alloc); 104 104 + 105 105 + for (result.rows) |row| { 106 106 + const content = row.text(2); 107 107 + const truncated = if (content.len > MAX_CONTENT_CHARS) 108 108 + try alloc.dupe(u8, content[0..MAX_CONTENT_CHARS]) 109 109 + else 110 110 + try alloc.dupe(u8, content); 111 111 + 112 112 + try docs.append(alloc, .{ 113 113 + .uri = try alloc.dupe(u8, row.text(0)), 114 114 + .title = try alloc.dupe(u8, row.text(1)), 115 115 + .content = truncated, 116 116 + .base_path = try alloc.dupe(u8, row.text(3)), 117 117 + .path = try alloc.dupe(u8, row.text(4)), 118 118 + .platform = try alloc.dupe(u8, row.text(5)), 119 119 + }); 120 120 + } 121 121 + 122 122 + return try docs.toOwnedSlice(alloc); 123 123 + } 124 124 + 125 125 + fn buildPrompt(alloc: Allocator, question: []const u8, docs: []const ContextDoc) ![]const u8 { 126 126 + var prompt: std.ArrayList(u8) = .empty; 127 127 + errdefer prompt.deinit(alloc); 128 128 + 129 129 + try prompt.appendSlice(alloc, 130 130 + \\You are a research assistant that answers questions based on a corpus of documents from ATProto publishing platforms (Leaflet, pckt, Offprint, etc.). 131 131 + \\ 132 132 + \\Answer the user's question based ONLY on the provided documents. If the documents don't contain relevant information, say so. 133 133 + \\ 134 134 + \\When citing sources, use markdown links like [title](url). Be concise but thorough. 135 135 + \\ 136 136 + \\## Documents 137 137 + \\ 138 138 + \\ 139 139 + ); 140 140 + 141 141 + for (docs, 0..) |doc, i| { 142 142 + const url = try doc.buildUrl(alloc); 143 143 + defer if (url.len > 0) alloc.free(url); 144 144 + 145 145 + // format doc header 146 146 + const header = try std.fmt.allocPrint(alloc, "### [{d}] {s}\n", .{ i + 1, doc.title }); 147 147 + defer alloc.free(header); 148 148 + try prompt.appendSlice(alloc, header); 149 149 + 150 150 + if (url.len > 0) { 151 151 + const url_line = try std.fmt.allocPrint(alloc, "URL: {s}\n", .{url}); 152 152 + defer alloc.free(url_line); 153 153 + try prompt.appendSlice(alloc, url_line); 154 154 + } 155 155 + 156 156 + try prompt.appendSlice(alloc, "\n"); 157 157 + try prompt.appendSlice(alloc, doc.content); 158 158 + try prompt.appendSlice(alloc, "\n\n"); 159 159 + } 160 160 + 161 161 + try prompt.appendSlice(alloc, "## Question\n\n"); 162 162 + try prompt.appendSlice(alloc, question); 163 163 + try prompt.appendSlice(alloc, "\n\n## Answer\n"); 164 164 + 165 165 + return try prompt.toOwnedSlice(alloc); 166 166 + } 167 167 + 168 168 + fn callClaude(alloc: Allocator, api_key: []const u8, prompt: []const u8) !?[]const u8 { 169 169 + const span = logfire.span("ask.claude_api", .{}); 170 170 + defer span.end(); 171 171 + 172 172 + var http_client: http.Client = .{ .allocator = alloc }; 173 173 + defer http_client.deinit(); 174 174 + 175 175 + // build request body 176 176 + const body = try buildClaudeRequest(alloc, prompt); 177 177 + defer alloc.free(body); 178 178 + 179 179 + var auth_buf: [256]u8 = undefined; 180 180 + const auth = std.fmt.bufPrint(&auth_buf, "{s}", .{api_key}) catch 181 181 + return error.AuthTooLong; 182 182 + 183 183 + var response_body: std.Io.Writer.Allocating = .init(alloc); 184 184 + errdefer response_body.deinit(); 185 185 + 186 186 + const res = http_client.fetch(.{ 187 187 + .location = .{ .url = "https://api.anthropic.com/v1/messages" }, 188 188 + .method = .POST, 189 189 + .headers = .{ 190 190 + .content_type = .{ .override = "application/json" }, 191 191 + .authorization = .{ .override = "" }, // not used, we use x-api-key 192 192 + }, 193 193 + .extra_headers = &.{ 194 194 + .{ .name = "x-api-key", .value = auth }, 195 195 + .{ .name = "anthropic-version", .value = "2023-06-01" }, 196 196 + }, 197 197 + .payload = body, 198 198 + .response_writer = &response_body.writer, 199 199 + }) catch |err| { 200 200 + logfire.err("ask: claude request failed: {}", .{err}); 201 201 + return null; 202 202 + }; 203 203 + 204 204 + if (res.status != .ok) { 205 205 + const resp_text = response_body.toOwnedSlice() catch ""; 206 206 + defer if (resp_text.len > 0) alloc.free(resp_text); 207 207 + logfire.err("ask: claude error {}: {s}", .{ res.status, resp_text[0..@min(resp_text.len, 500)] }); 208 208 + return null; 209 209 + } 210 210 + 211 211 + const response_text = try response_body.toOwnedSlice(); 212 212 + defer alloc.free(response_text); 213 213 + 214 214 + return try parseClaudeResponse(alloc, response_text); 215 215 + } 216 216 + 217 217 + fn buildClaudeRequest(alloc: Allocator, prompt: []const u8) ![]const u8 { 218 218 + var body: std.Io.Writer.Allocating = .init(alloc); 219 219 + errdefer body.deinit(); 220 220 + var jw: json.Stringify = .{ .writer = &body.writer }; 221 221 + 222 222 + try jw.beginObject(); 223 223 + 224 224 + try jw.objectField("model"); 225 225 + try jw.write(CLAUDE_MODEL); 226 226 + 227 227 + try jw.objectField("max_tokens"); 228 228 + try jw.write(@as(i64, 2048)); 229 229 + 230 230 + try jw.objectField("messages"); 231 231 + try jw.beginArray(); 232 232 + try jw.beginObject(); 233 233 + try jw.objectField("role"); 234 234 + try jw.write("user"); 235 235 + try jw.objectField("content"); 236 236 + try jw.write(prompt); 237 237 + try jw.endObject(); 238 238 + try jw.endArray(); 239 239 + 240 240 + try jw.endObject(); 241 241 + 242 242 + return try body.toOwnedSlice(); 243 243 + } 244 244 + 245 245 + fn parseClaudeResponse(alloc: Allocator, response: []const u8) ![]const u8 { 246 246 + const parsed = json.parseFromSlice(json.Value, alloc, response, .{}) catch { 247 247 + logfire.err("ask: failed to parse claude response", .{}); 248 248 + return error.ParseError; 249 249 + }; 250 250 + defer parsed.deinit(); 251 251 + 252 252 + const content = parsed.value.object.get("content") orelse return error.MissingContent; 253 253 + if (content != .array or content.array.items.len == 0) return error.InvalidContent; 254 254 + 255 255 + const first_block = content.array.items[0]; 256 256 + const text = first_block.object.get("text") orelse return error.MissingText; 257 257 + if (text != .string) return error.InvalidText; 258 258 + 259 259 + return try alloc.dupe(u8, text.string); 260 260 + } 261 261 + 262 262 + fn serializeResponse(alloc: Allocator, answer: []const u8, docs: []const ContextDoc) ![]const u8 { 263 263 + var output: std.Io.Writer.Allocating = .init(alloc); 264 264 + errdefer output.deinit(); 265 265 + var jw: json.Stringify = .{ .writer = &output.writer }; 266 266 + 267 267 + try jw.beginObject(); 268 268 + 269 269 + try jw.objectField("answer"); 270 270 + try jw.write(answer); 271 271 + 272 272 + try jw.objectField("sources"); 273 273 + try jw.beginArray(); 274 274 + for (docs) |doc| { 275 275 + const url = try doc.buildUrl(alloc); 276 276 + defer if (url.len > 0) alloc.free(url); 277 277 + 278 278 + try jw.beginObject(); 279 279 + try jw.objectField("uri"); 280 280 + try jw.write(doc.uri); 281 281 + try jw.objectField("title"); 282 282 + try jw.write(doc.title); 283 283 + try jw.objectField("url"); 284 284 + try jw.write(url); 285 285 + try jw.endObject(); 286 286 + } 287 287 + try jw.endArray(); 288 288 + 289 289 + try jw.endObject(); 290 290 + 291 291 + return try output.toOwnedSlice(); 292 292 + } 293 293 + 294 294 + fn serializeError(alloc: Allocator, message: []const u8) ![]const u8 { 295 295 + var output: std.Io.Writer.Allocating = .init(alloc); 296 296 + errdefer output.deinit(); 297 297 + var jw: json.Stringify = .{ .writer = &output.writer }; 298 298 + 299 299 + try jw.beginObject(); 300 300 + try jw.objectField("error"); 301 301 + try jw.write(message); 302 302 + try jw.endObject(); 303 303 + 304 304 + return try output.toOwnedSlice(); 305 305 + }

+31

backend/src/server.zig

··· 9 9 const stats = @import("stats.zig"); 10 10 const timing = @import("timing.zig"); 11 11 const dashboard = @import("dashboard.zig"); 12 12 + const ask_mod = @import("ask.zig"); 12 13 13 14 const HTTP_BUF_SIZE = 8192; 14 15 const QUERY_PARAM_BUF_SIZE = 64; ··· 69 70 try handleSimilar(request, target); 70 71 } else if (mem.eql(u8, target, "/activity")) { 71 72 try handleActivity(request); 73 73 + } else if (mem.startsWith(u8, target, "/ask")) { 74 74 + try handleAsk(request, target); 72 75 } else { 73 76 try sendNotFound(request); 74 77 } ··· 336 339 337 340 try sendJson(request, stream.getWritten()); 338 341 } 342 342 + 343 343 + fn handleAsk(request: *http.Server.Request, target: []const u8) !void { 344 344 + const start_time = std.time.microTimestamp(); 345 345 + defer timing.record(.ask, start_time); 346 346 + 347 347 + var arena = std.heap.ArenaAllocator.init(std.heap.page_allocator); 348 348 + defer arena.deinit(); 349 349 + const alloc = arena.allocator(); 350 350 + 351 351 + const question = parseQueryParam(alloc, target, "q") catch ""; 352 352 + 353 353 + const span = logfire.span("http.ask", .{ .question = question }); 354 354 + defer span.end(); 355 355 + 356 356 + if (question.len == 0) { 357 357 + try sendJson(request, "{\"error\":\"missing q parameter\"}"); 358 358 + return; 359 359 + } 360 360 + 361 361 + const result = ask_mod.ask(alloc, question) catch |err| { 362 362 + logfire.err("ask failed: {}", .{err}); 363 363 + stats.recordError(); 364 364 + try sendJson(request, "{\"error\":\"synthesis failed\"}"); 365 365 + return; 366 366 + }; 367 367 + 368 368 + try sendJson(request, result); 369 369 + }

+1

backend/src/timing.zig

··· 6 6 similar, 7 7 tags, 8 8 popular, 9 9 + ask, 9 10 10 11 pub fn name(self: Endpoint) []const u8 { 11 12 return @tagName(self);

+227 -2

site/index.html

··· 65 65 color: #1B7340; 66 66 } 67 67 68 68 + /* mode toggle - experimental aesthetic */ 69 69 + .mode-toggle { 70 70 + display: flex; 71 71 + align-items: center; 72 72 + gap: 0.5rem; 73 73 + margin-bottom: 1rem; 74 74 + font-size: 12px; 75 75 + } 76 76 + 77 77 + .mode-toggle .mode { 78 78 + padding: 4px 10px; 79 79 + cursor: pointer; 80 80 + color: #555; 81 81 + border-bottom: 2px solid transparent; 82 82 + transition: all 0.15s; 83 83 + } 84 84 + 85 85 + .mode-toggle .mode:hover { 86 86 + color: #888; 87 87 + } 88 88 + 89 89 + .mode-toggle .mode.active { 90 90 + color: #ccc; 91 91 + border-bottom-color: #1B7340; 92 92 + } 93 93 + 94 94 + .mode-toggle .mode.experimental { 95 95 + position: relative; 96 96 + } 97 97 + 98 98 + .mode-toggle .mode.experimental::after { 99 99 + content: 'experimental'; 100 100 + position: absolute; 101 101 + top: -8px; 102 102 + right: -4px; 103 103 + font-size: 7px; 104 104 + color: #d4956a; 105 105 + background: rgba(180, 100, 64, 0.2); 106 106 + padding: 1px 3px; 107 107 + border-radius: 2px; 108 108 + text-transform: uppercase; 109 109 + letter-spacing: 0.5px; 110 110 + } 111 111 + 112 112 + .mode-toggle .mode.experimental.active { 113 113 + border-bottom-style: dashed; 114 114 + border-bottom-color: #d4956a; 115 115 + color: #d4956a; 116 116 + } 117 117 + 118 118 + /* ask response styling */ 119 119 + .ask-response { 120 120 + border: 1px dashed #d4956a; 121 121 + border-radius: 4px; 122 122 + padding: 1rem; 123 123 + margin-bottom: 1rem; 124 124 + background: rgba(180, 100, 64, 0.05); 125 125 + } 126 126 + 127 127 + .ask-response .answer { 128 128 + color: #ccc; 129 129 + line-height: 1.7; 130 130 + font-size: 13px; 131 131 + } 132 132 + 133 133 + .ask-response .answer a { 134 134 + color: #d4956a; 135 135 + } 136 136 + 137 137 + .ask-response .answer a:hover { 138 138 + color: #e8b08a; 139 139 + } 140 140 + 141 141 + .ask-sources { 142 142 + margin-top: 1rem; 143 143 + padding-top: 1rem; 144 144 + border-top: 1px solid #222; 145 145 + } 146 146 + 147 147 + .ask-sources-label { 148 148 + font-size: 10px; 149 149 + color: #555; 150 150 + text-transform: uppercase; 151 151 + letter-spacing: 0.5px; 152 152 + margin-bottom: 0.5rem; 153 153 + } 154 154 + 155 155 + .ask-source { 156 156 + display: inline-block; 157 157 + font-size: 11px; 158 158 + padding: 3px 8px; 159 159 + margin: 0 0.5rem 0.5rem 0; 160 160 + background: #111; 161 161 + border: 1px solid #222; 162 162 + border-radius: 3px; 163 163 + color: #888; 164 164 + text-decoration: none; 165 165 + } 166 166 + 167 167 + .ask-source:hover { 168 168 + background: #1a1a1a; 169 169 + border-color: #333; 170 170 + color: #aaa; 171 171 + } 172 172 + 173 173 + .ask-thinking { 174 174 + color: #d4956a; 175 175 + font-size: 12px; 176 176 + animation: pulse 1.5s ease-in-out infinite; 177 177 + } 178 178 + 179 179 + .ask-error { 180 180 + color: #c44; 181 181 + font-size: 12px; 182 182 + padding: 1rem; 183 183 + border: 1px dashed #c44; 184 184 + border-radius: 4px; 185 185 + background: rgba(200, 60, 60, 0.05); 186 186 + } 187 187 + 68 188 .search-box { 69 189 display: flex; 70 190 gap: 0.5rem; ··· 507 627 font-size: 11px; 508 628 padding: 0.5rem; 509 629 } 630 630 + 631 631 + /* mode toggle mobile */ 632 632 + .mode-toggle .mode { 633 633 + min-height: 44px; 634 634 + display: inline-flex; 635 635 + align-items: center; 636 636 + } 510 637 } 511 638 512 639 /* ensure touch targets on tablets too */ ··· 522 649 <body> 523 650 <div class="container"> 524 651 <h1><a href="/" class="title">pub search</a> <span class="by">by <a href="https://bsky.app/profile/zzstoatzz.io" target="_blank">@zzstoatzz.io</a></span> <a href="https://tangled.sh/@zzstoatzz.io/leaflet-search" target="_blank" class="src">[src]</a></h1> 652 652 + 653 653 + <div class="mode-toggle"> 654 654 + <span class="mode active" id="mode-search" onclick="setMode('search')">search</span> 655 655 + <span class="mode experimental" id="mode-ask" onclick="setMode('ask')">ask</span> 656 656 + </div> 525 657 526 658 <div class="search-box"> 527 659 <input type="text" id="query" placeholder="search content..." autofocus> ··· 562 694 563 695 let currentTag = null; 564 696 let currentPlatform = null; 697 697 + let currentMode = 'search'; // 'search' or 'ask' 565 698 let allTags = []; 566 699 let popularSearches = []; 700 700 + 701 701 + function setMode(mode) { 702 702 + currentMode = mode; 703 703 + document.getElementById('mode-search').classList.toggle('active', mode === 'search'); 704 704 + document.getElementById('mode-ask').classList.toggle('active', mode === 'ask'); 705 705 + 706 706 + // update UI based on mode 707 707 + if (mode === 'ask') { 708 708 + queryInput.placeholder = 'ask a question...'; 709 709 + searchBtn.textContent = 'ask'; 710 710 + // hide filters and suggestions in ask mode (they don't apply) 711 711 + tagsDiv.style.display = 'none'; 712 712 + platformFilterDiv.style.display = 'none'; 713 713 + activeFilterDiv.style.display = 'none'; 714 714 + suggestionsDiv.style.display = 'none'; 715 715 + // show ask-specific empty state 716 716 + resultsDiv.innerHTML = ` 717 717 + <div class="empty-state"> 718 718 + <p style="color:#d4956a">ask questions about the corpus</p> 719 719 + <p style="font-size:11px;margin-top:0.5rem;color:#666">e.g. "what approaches do writers take to deploying prefect flows?"</p> 720 720 + </div> 721 721 + `; 722 722 + statsDiv.textContent = ''; 723 723 + } else { 724 724 + queryInput.placeholder = 'search content...'; 725 725 + searchBtn.textContent = 'search'; 726 726 + tagsDiv.style.display = ''; 727 727 + platformFilterDiv.style.display = ''; 728 728 + activeFilterDiv.style.display = ''; 729 729 + suggestionsDiv.style.display = ''; 730 730 + renderEmptyState(); 731 731 + } 732 732 + } 567 733 568 734 async function search(query, tag = null, platform = null) { 569 735 if (!query.trim() && !tag && !platform) return; ··· 795 961 } 796 962 797 963 function doSearch() { 798 798 - updateUrl(); 799 799 - search(queryInput.value, currentTag, currentPlatform); 964 964 + if (currentMode === 'ask') { 965 965 + doAsk(); 966 966 + } else { 967 967 + updateUrl(); 968 968 + search(queryInput.value, currentTag, currentPlatform); 969 969 + } 970 970 + } 971 971 + 972 972 + async function doAsk() { 973 973 + const question = queryInput.value.trim(); 974 974 + if (!question) return; 975 975 + 976 976 + searchBtn.disabled = true; 977 977 + resultsDiv.innerHTML = `<div class="ask-thinking">thinking about "${escapeHtml(question)}"...</div>`; 978 978 + 979 979 + try { 980 980 + const res = await fetch(`${API_URL}/ask?q=${encodeURIComponent(question)}`); 981 981 + const data = await res.json(); 982 982 + 983 983 + if (data.error) { 984 984 + resultsDiv.innerHTML = `<div class="ask-error">${escapeHtml(data.error)}</div>`; 985 985 + return; 986 986 + } 987 987 + 988 988 + // render the synthesized answer 989 989 + let html = `<div class="ask-response">`; 990 990 + html += `<div class="answer">${formatAnswer(data.answer)}</div>`; 991 991 + 992 992 + if (data.sources && data.sources.length > 0) { 993 993 + html += `<div class="ask-sources">`; 994 994 + html += `<div class="ask-sources-label">sources (${data.sources.length})</div>`; 995 995 + for (const src of data.sources) { 996 996 + if (src.url) { 997 997 + html += `<a href="${escapeHtml(src.url)}" target="_blank" class="ask-source">${escapeHtml(src.title || 'Untitled')}</a>`; 998 998 + } else { 999 999 + html += `<span class="ask-source">${escapeHtml(src.title || 'Untitled')}</span>`; 1000 1000 + } 1001 1001 + } 1002 1002 + html += `</div>`; 1003 1003 + } 1004 1004 + 1005 1005 + html += `</div>`; 1006 1006 + resultsDiv.innerHTML = html; 1007 1007 + statsDiv.textContent = ''; 1008 1008 + 1009 1009 + } catch (err) { 1010 1010 + resultsDiv.innerHTML = `<div class="ask-error">failed to get answer: ${escapeHtml(err.message)}</div>`; 1011 1011 + } finally { 1012 1012 + searchBtn.disabled = false; 1013 1013 + } 1014 1014 + } 1015 1015 + 1016 1016 + function formatAnswer(text) { 1017 1017 + if (!text) return ''; 1018 1018 + // escape HTML first 1019 1019 + let html = escapeHtml(text); 1020 1020 + // convert markdown links [title](url) to HTML links 1021 1021 + html = html.replace(/\[([^\]]+)\]\(([^)]+)\)/g, '<a href="$2" target="_blank">$1</a>'); 1022 1022 + // convert newlines to <br> 1023 1023 + html = html.replace(/\n/g, '<br>'); 1024 1024 + return html; 800 1025 } 801 1026 802 1027 function setTag(tag) {