tags, falling back to all
), trimmed +// and capped at MaxBodyChars. Returns "" on any fetch failure. +func FetchArticleBody(articleURL string) string { + if articleURL == "" { + return "" + } + ctx, cancel := context.WithTimeout(context.Background(), 12*time.Second) + defer cancel() + + req, err := http.NewRequestWithContext(ctx, "GET", articleURL, nil) + if err != nil { + return "" + } + req.Header.Set("User-Agent", userAgent) + req.Header.Set("Accept", "text/html,application/xhtml+xml") + + resp, err := articleClient.Do(req) + if err != nil { + return "" + } + defer resp.Body.Close() + if resp.StatusCode != http.StatusOK { + return "" + } + + doc, err := goquery.NewDocumentFromReader(resp.Body) + if err != nil { + return "" + } + return extractBodyText(doc) +} + +func extractBodyText(doc *goquery.Document) string { + sel := doc.Find("article p, main p") + if sel.Length() == 0 { + sel = doc.Find("p") + } + var b strings.Builder + sel.Each(func(_ int, s *goquery.Selection) { + t := strings.TrimSpace(s.Text()) + if t == "" { + return + } + if b.Len() > 0 { + b.WriteString("\n\n") + } + b.WriteString(t) + if b.Len() >= MaxBodyChars { + return + } + }) + out := strings.TrimSpace(b.String()) + if len(out) > MaxBodyChars { + out = out[:MaxBodyChars] + } + return out +} + func extractOGImage(doc *goquery.Document, base string) string { selectors := []string{ `meta[property="og:image:secure_url"]`, diff --git a/internal/matrix/client.go b/internal/matrix/client.go index e36dc64..cbf0943 100644 --- a/internal/matrix/client.go +++ b/internal/matrix/client.go @@ -294,6 +294,35 @@ func (c *Client) Stop() { } } +// PostThreadedReply sends a plain/HTML message into the thread rooted at +// rootEventID. Resolves channel name → room ID like PostStory. The is_falling_back +// flag plus m.in_reply_to gives non-thread-aware clients a sensible quoted reply. +func (c *Client) PostThreadedReply(channel string, rootEventID id.EventID, plain, htmlBody string) error { + roomID, ok := c.channels[channel] + if !ok { + return fmt.Errorf("unknown channel: %s", channel) + } + ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second) + defer cancel() + + content := &event.MessageEventContent{ + MsgType: event.MsgText, + Body: plain, + Format: event.FormatHTML, + FormattedBody: htmlBody, + RelatesTo: &event.RelatesTo{ + Type: event.RelThread, + EventID: rootEventID, + InReplyTo: &event.InReplyTo{ + EventID: rootEventID, + }, + IsFallingBack: true, + }, + } + _, err := c.mx.SendMessageEvent(ctx, roomID, event.EventMessage, content) + return err +} + // PostStory sends a story to a channel. Returns the text event ID for reaction tracking. // If the story has a validated image, it's uploaded and sent as a separate m.image event first. func (c *Client) PostStory(channel string, story *PostableStory) (id.EventID, error) { diff --git a/internal/poster/tracker.go b/internal/poster/tracker.go index 4a2685c..80e8efb 100644 --- a/internal/poster/tracker.go +++ b/internal/poster/tracker.go @@ -2,6 +2,7 @@ package poster import ( "log/slog" + "sync" "time" "pete/internal/storage" @@ -9,6 +10,24 @@ import ( "maunium.net/go/mautrix/id" ) +// ReactionCallback is an optional hook fired after a reaction is recorded. +// Used to wire reaction-driven features (e.g. ❓ → summary) without coupling +// poster to those packages. +type ReactionCallback func(roomID id.RoomID, targetEventID id.EventID, guid, channel, emoji string) + +var ( + reactionCallbackMu sync.RWMutex + reactionCallback ReactionCallback +) + +// SetReactionCallback installs a hook called after every recorded reaction. +// Pass nil to clear. Safe to call before or after the matrix client starts. +func SetReactionCallback(fn ReactionCallback) { + reactionCallbackMu.Lock() + reactionCallback = fn + reactionCallbackMu.Unlock() +} + // HandleReaction processes a reaction event by mapping it back to the story GUID. func HandleReaction(roomID id.RoomID, eventID id.EventID, targetEventID id.EventID, emoji string, userID id.UserID) { guid, channel, found := storage.LookupPostGUID(string(targetEventID)) @@ -24,4 +43,11 @@ func HandleReaction(roomID id.RoomID, eventID id.EventID, targetEventID id.Event "emoji", emoji, "user", userID, ) + + reactionCallbackMu.RLock() + cb := reactionCallback + reactionCallbackMu.RUnlock() + if cb != nil { + go cb(roomID, targetEventID, guid, channel, emoji) + } } diff --git a/internal/storage/queries.go b/internal/storage/queries.go index 6feeec0..9716804 100644 --- a/internal/storage/queries.go +++ b/internal/storage/queries.go @@ -118,6 +118,18 @@ func GetUnclassifiedStories(source string) ([]Story, error) { return stories, rows.Err() } +// GetStoryByGUID returns the full story record for a GUID, or nil if not found. +func GetStoryByGUID(guid string) (*Story, error) { + row := Get().QueryRow( + `SELECT guid, headline, lede, image_url, article_url, source, feed_hint, platforms, channel, seen_at + FROM stories WHERE guid = ?`, guid) + var s Story + if err := row.Scan(&s.GUID, &s.Headline, &s.Lede, &s.ImageURL, &s.ArticleURL, &s.Source, &s.FeedHint, &s.Platforms, &s.Channel, &s.SeenAt); err != nil { + return nil, err + } + return &s, nil +} + // InsertRecentHeadline adds a headline to the dedup context window. func InsertRecentHeadline(guid, headline, source string) { exec("insert recent_headline", diff --git a/main.go b/main.go index b57d93b..1a5a12c 100644 --- a/main.go +++ b/main.go @@ -11,6 +11,7 @@ import ( "pete/internal/classifier" "pete/internal/config" + "pete/internal/explainer" "pete/internal/ingestion" "pete/internal/matrix" "pete/internal/poster" @@ -73,8 +74,10 @@ func main() { // Create post queue queue := poster.NewQueue(cfg.Posting, mx) - // Wire reaction handler + // Wire reaction handler + ❓ → summary hook mx.SetReactionHandler(poster.HandleReaction) + exp := explainer.New(mx, ollamaClient) + poster.SetReactionCallback(exp.Handle) // Set up graceful shutdown ctx, cancel := context.WithCancel(context.Background())