// retoor <retoor@molodetz.nl>
import Foundation
#if canImport(FoundationNetworking)
import FoundationNetworking
#endif
import SwiftDevRant
struct ExternalMention: Decodable {
let from: String
let to: String
let content: String
let rantId: Int
let commentId: Int
let createdTime: Int
let identifiers: Identifiers
struct Identifiers: Decodable {
let guid: String
let uniqueKey: String
enum CodingKeys: String, CodingKey {
case guid
case uniqueKey = "unique_key"
}
}
enum CodingKeys: String, CodingKey {
case from, to, content
case rantId = "rant_id"
case commentId = "comment_id"
case createdTime = "created_time"
case identifiers
}
}
actor MentionBot {
private static let mentionsURL = "https://static.molodetz.nl/dr.mentions.json"
private let api: DevRantRequest
private let token: AuthToken
private let ai: OpenRouterClient
private let logger: BotLogger
private let stateManager: StateManager
private let botUsername: String
private let dryRun: Bool
private var processedThisSession: Set<String> = []
init(
api: DevRantRequest,
token: AuthToken,
ai: OpenRouterClient,
logger: BotLogger,
stateManager: StateManager,
botUsername: String,
dryRun: Bool = false
) {
self.api = api
self.token = token
self.ai = ai
self.logger = logger
self.stateManager = stateManager
self.botUsername = botUsername.lowercased()
self.dryRun = dryRun
}
func run(continuous: Bool, intervalSeconds: Int) async {
await logger.info("MentionBot started as @\(botUsername). Dry run: \(dryRun)")
repeat {
await checkMentions()
if continuous {
await logger.debug("Sleeping for \(intervalSeconds) seconds...")
try? await Task.sleep(nanoseconds: UInt64(intervalSeconds) * 1_000_000_000)
}
} while continuous
}
private func checkMentions() async {
await logger.debug("Checking for mentions...")
do {
let mentions = try await fetchExternalMentions()
let lastTime = await stateManager.lastMentionTime
let newMentions = mentions.filter { mention in
mention.to.lowercased() == botUsername &&
mention.createdTime > lastTime &&
!processedThisSession.contains(mention.identifiers.guid)
}
if newMentions.isEmpty {
await logger.debug("No new mentions")
return
}
await logger.info("Found \(newMentions.count) new mention(s)")
for mention in newMentions.sorted(by: { $0.createdTime < $1.createdTime }) {
await processMention(mention)
}
} catch {
await logger.error("Failed to check mentions: \(error)")
}
}
private func fetchExternalMentions() async throws -> [ExternalMention] {
guard let url = URL(string: Self.mentionsURL) else {
throw MentionError.invalidURL
}
let (data, response) = try await URLSession.shared.data(from: url)
guard let httpResponse = response as? HTTPURLResponse, httpResponse.statusCode == 200 else {
throw MentionError.fetchFailed
}
return try JSONDecoder().decode([ExternalMention].self, from: data)
}
private func processMention(_ mention: ExternalMention) async {
guard !processedThisSession.contains(mention.identifiers.guid) else {
await logger.debug("Already processed mention: \(mention.identifiers.guid)")
return
}
processedThisSession.insert(mention.identifiers.guid)
do {
let (rant, comments) = try await api.getRant(
token: token,
rantId: mention.rantId,
lastCommentId: nil
)
guard let mentionComment = comments.first(where: { $0.id == mention.commentId }) else {
await logger.warning("Could not find mention comment \(mention.commentId) in rant \(mention.rantId)")
return
}
let question = extractQuestion(from: mention.content)
await logger.info("Mention from @\(mention.from): \(question.prefix(100))...")
let context = buildContext(rant: rant, comments: comments, mentionComment: mentionComment)
let response = try await ai.chat(message: question, context: context)
await logger.info("AI response: \(response.prefix(100))...")
await postReply(
rantId: mention.rantId,
replyTo: mention.from,
response: response
)
await stateManager.updateLastMentionTime(mention.createdTime)
} catch {
await logger.error("Failed to process mention: \(error)")
}
}
private func extractQuestion(from text: String) -> String {
var cleaned = text
let mentionPattern = try? NSRegularExpression(
pattern: "@\(NSRegularExpression.escapedPattern(for: botUsername))",
options: [.caseInsensitive]
)
if let pattern = mentionPattern {
let range = NSRange(cleaned.startIndex..., in: cleaned)
cleaned = pattern.stringByReplacingMatches(
in: cleaned,
options: [],
range: range,
withTemplate: ""
)
}
return cleaned.trimmingCharacters(in: .whitespacesAndNewlines)
}
private func buildContext(rant: Rant, comments: [Comment], mentionComment: Comment) -> String {
var context = "Original rant by @\(rant.author.name):\n\(rant.text)\n\n"
let relevantComments = comments.filter { $0.id != mentionComment.id }
.suffix(5)
if !relevantComments.isEmpty {
context += "Recent comments:\n"
for comment in relevantComments {
context += "- @\(comment.author.name): \(comment.text.prefix(200))\n"
}
}
return context
}
private func filterSelfMentions(from text: String) -> String {
guard let pattern = try? NSRegularExpression(
pattern: "@\(NSRegularExpression.escapedPattern(for: botUsername))",
options: [.caseInsensitive]
) else {
return text
}
let range = NSRange(text.startIndex..., in: text)
return pattern.stringByReplacingMatches(
in: text,
options: [],
range: range,
withTemplate: ""
).replacingOccurrences(of: " ", with: " ")
.trimmingCharacters(in: .whitespaces)
}
private func postReply(rantId: Int, replyTo: String, response: String) async {
let filteredResponse = filterSelfMentions(from: response)
let reply = "@\(replyTo) \(filteredResponse)"
guard !dryRun else {
await logger.info("DRY RUN: Would post reply to rant \(rantId):\n\(reply)")
return
}
do {
try await api.postComment(
token: token,
rantId: rantId,
text: reply,
image: nil
)
await logger.info("Posted reply to rant \(rantId)")
} catch {
await logger.error("Failed to post reply: \(error)")
}
}
func getStats() -> Int {
return processedThisSession.count
}
}
enum MentionError: Error {
case invalidURL
case fetchFailed
}
Reference in New Issue View Git Blame Copy Permalink