refactor rules to use new helpers package

automod/rules/harassment.go

···
 	"github.com/bluesky-social/indigo/atproto/syntax"
 	"github.com/bluesky-social/indigo/automod"
 	"github.com/bluesky-social/indigo/automod/countstore"
+	"github.com/bluesky-social/indigo/automod/helpers"
 )
 
 var _ automod.PostRuleFunc = HarassmentTargetInteractionPostRule
 
 // looks for new accounts, which interact with frequently-harassed accounts, and report them for review
 func HarassmentTargetInteractionPostRule(c *automod.RecordContext, post *appbsky.FeedPost) error {
-	if c.Account.Identity == nil || !AccountIsYoungerThan(&c.AccountContext, 24*time.Hour) {
+	if c.Account.Identity == nil || !helpers.AccountIsYoungerThan(&c.AccountContext, 24*time.Hour) {
 		return nil
 	}
 
 	var interactionDIDs []string
-	facets, err := ExtractFacets(post)
+	facets, err := helpers.ExtractFacets(post)
 	if err != nil {
 		return err
 	}
···
 			interactionDIDs = append(interactionDIDs, *pf.DID)
 		}
 	}
-	if post.Reply != nil && !IsSelfThread(c, post) {
+	if post.Reply != nil && !helpers.IsSelfThread(c, post) {
 		parentURI, err := syntax.ParseATURI(post.Reply.Parent.Uri)
 		if err != nil {
 			return err
···
 		return nil
 	}
 
-	interactionDIDs = dedupeStrings(interactionDIDs)
+	interactionDIDs = helpers.DedupeStrings(interactionDIDs)
 	for _, d := range interactionDIDs {
 		did, err := syntax.ParseDID(d)
 		if err != nil {
···
 
 // looks for new accounts, which frequently post the same type of content
 func HarassmentTrivialPostRule(c *automod.RecordContext, post *appbsky.FeedPost) error {
-	if c.Account.Identity == nil || !AccountIsYoungerThan(&c.AccountContext, 7*24*time.Hour) {
+	if c.Account.Identity == nil || !helpers.AccountIsYoungerThan(&c.AccountContext, 7*24*time.Hour) {
 		return nil
 	}
 

automod/rules/hashtags.go

···
 
 	appbsky "github.com/bluesky-social/indigo/api/bsky"
 	"github.com/bluesky-social/indigo/automod"
+	"github.com/bluesky-social/indigo/automod/helpers"
 	"github.com/bluesky-social/indigo/automod/keyword"
 )
 
 // looks for specific hashtags from known lists
 func BadHashtagsPostRule(c *automod.RecordContext, post *appbsky.FeedPost) error {
-	for _, tag := range ExtractHashtagsPost(post) {
-		tag = NormalizeHashtag(tag)
+	for _, tag := range helpers.ExtractHashtagsPost(post) {
+		tag = helpers.NormalizeHashtag(tag)
 		// skip some bad-word hashtags which frequently false-positive
 		if tag == "nazi" || tag == "hitler" {
 			continue
···
 
 // if a post is "almost all" hashtags, it might be a form of search spam
 func TooManyHashtagsPostRule(c *automod.RecordContext, post *appbsky.FeedPost) error {
-	tags := ExtractHashtagsPost(post)
+	tags := helpers.ExtractHashtagsPost(post)
 	tagChars := 0
 	for _, tag := range tags {
 		tagChars += len(tag)

automod/rules/identity.go

···
 
 	"github.com/bluesky-social/indigo/automod"
 	"github.com/bluesky-social/indigo/automod/countstore"
+	"github.com/bluesky-social/indigo/automod/helpers"
 )
 
 // triggers on first identity event for an account (DID)
 func NewAccountRule(c *automod.AccountContext) error {
-	if c.Account.Identity == nil || !AccountIsYoungerThan(c, 4*time.Hour) {
+	if c.Account.Identity == nil || !helpers.AccountIsYoungerThan(c, 4*time.Hour) {
 		return nil
 	}
 

automod/rules/keyword.go

···
 
 	appbsky "github.com/bluesky-social/indigo/api/bsky"
 	"github.com/bluesky-social/indigo/automod"
+	"github.com/bluesky-social/indigo/automod/helpers"
 	"github.com/bluesky-social/indigo/automod/keyword"
 )
 
···
 			isJapanese = true
 		}
 	}
-	for _, tok := range ExtractTextTokensPost(post) {
+	for _, tok := range helpers.ExtractTextTokensPost(post) {
 		word := keyword.SlugIsExplicitSlur(tok)
 		// used very frequently in a reclaimed context
 		if word != "" && word != "faggot" && word != "tranny" && word != "coon" && !(word == "kike" && isJapanese) {
···
 			//c.Notify("slack")
 		}
 	}
-	for _, tok := range ExtractTextTokensProfile(profile) {
+	for _, tok := range helpers.ExtractTextTokensProfile(profile) {
 		// de-pluralize
 		tok = strings.TrimSuffix(tok, "s")
 		if c.InSet("worst-words", tok) {
···
 
 // looks for the specific harassment situation of a replay to another user with only a single word
 func ReplySingleBadWordPostRule(c *automod.RecordContext, post *appbsky.FeedPost) error {
-	if post.Reply != nil && !IsSelfThread(c, post) {
-		tokens := ExtractTextTokensPost(post)
+	if post.Reply != nil && !helpers.IsSelfThread(c, post) {
+		tokens := helpers.ExtractTextTokensPost(post)
 		if len(tokens) != 1 {
 			return nil
 		}

automod/rules/mentions.go

···
 	"github.com/bluesky-social/indigo/atproto/syntax"
 	"github.com/bluesky-social/indigo/automod"
 	"github.com/bluesky-social/indigo/automod/countstore"
+	"github.com/bluesky-social/indigo/automod/helpers"
 )
 
 var _ automod.PostRuleFunc = DistinctMentionsRule
···
 var _ automod.PostRuleFunc = YoungAccountDistinctMentionsRule
 
 func YoungAccountDistinctMentionsRule(c *automod.RecordContext, post *appbsky.FeedPost) error {
-	if c.Account.Identity == nil || !AccountIsYoungerThan(&c.AccountContext, 14*24*time.Hour) {
+	if c.Account.Identity == nil || !helpers.AccountIsYoungerThan(&c.AccountContext, 14*24*time.Hour) {
 		return nil
 	}
 

automod/rules/misleading.go

···
 	appbsky "github.com/bluesky-social/indigo/api/bsky"
 	"github.com/bluesky-social/indigo/atproto/syntax"
 	"github.com/bluesky-social/indigo/automod"
+	"github.com/bluesky-social/indigo/automod/helpers"
 )
 
-func isMisleadingURLFacet(facet PostFacet, logger *slog.Logger) bool {
+func isMisleadingURLFacet(facet helpers.PostFacet, logger *slog.Logger) bool {
 	linkURL, err := url.Parse(*facet.URL)
 	if err != nil {
 		logger.Warn("invalid link metadata URL", "url", facet.URL)
···
 	if c.Account.Identity.Handle == "nowbreezing.ntw.app" {
 		return nil
 	}
-	facets, err := ExtractFacets(post)
+	facets, err := helpers.ExtractFacets(post)
 	if err != nil {
 		c.Logger.Warn("invalid facets", "err", err)
 		// TODO: or some other "this record is corrupt" indicator?
···
 var _ automod.PostRuleFunc = MisleadingMentionPostRule
 
 func MisleadingMentionPostRule(c *automod.RecordContext, post *appbsky.FeedPost) error {
-	facets, err := ExtractFacets(post)
+	facets, err := helpers.ExtractFacets(post)
 	if err != nil {
 		c.Logger.Warn("invalid facets", "err", err)
 		// TODO: or some other "this record is corrupt" indicator?

automod/rules/misleading_test.go

···
 	"github.com/bluesky-social/indigo/atproto/syntax"
 	"github.com/bluesky-social/indigo/automod"
 	"github.com/bluesky-social/indigo/automod/engine"
+	"github.com/bluesky-social/indigo/automod/helpers"
 
 	"github.com/stretchr/testify/assert"
 )
···
 	logger := slog.Default()
 
 	fixtures := []struct {
-		facet PostFacet
+		facet helpers.PostFacet
 		out   bool
 	}{
 		{
-			facet: PostFacet{
+			facet: helpers.PostFacet{
 				Text: "https://atproto.com",
 				URL:  pstr("https://atproto.com"),
 			},
 			out: false,
 		},
 		{
-			facet: PostFacet{
+			facet: helpers.PostFacet{
 				Text: "https://atproto.com",
 				URL:  pstr("https://evil.com"),
 			},
 			out: true,
 		},
 		{
-			facet: PostFacet{
+			facet: helpers.PostFacet{
 				Text: "https://www.atproto.com",
 				URL:  pstr("https://atproto.com"),
 			},
 			out: false,
 		},
 		{
-			facet: PostFacet{
+			facet: helpers.PostFacet{
 				Text: "https://atproto.com",
 				URL:  pstr("https://www.atproto.com"),
 			},
 			out: false,
 		},
 		{
-			facet: PostFacet{
+			facet: helpers.PostFacet{
 				Text: "[example.com]",
 				URL:  pstr("https://www.example.com"),
 			},
 			out: false,
 		},
 		{
-			facet: PostFacet{
+			facet: helpers.PostFacet{
 				Text: "example.com...",
 				URL:  pstr("https://example.com.evil.com"),
 			},
 			out: true,
 		},
 		{
-			facet: PostFacet{
+			facet: helpers.PostFacet{
 				Text: "ATPROTO.com...",
 				URL:  pstr("https://atproto.com"),
 			},
 			out: false,
 		},
 		{
-			facet: PostFacet{
+			facet: helpers.PostFacet{
 				Text: "1234.5678",
 				URL:  pstr("https://arxiv.org/abs/1234.5678"),
 			},
 			out: false,
 		},
 		{
-			facet: PostFacet{
+			facet: helpers.PostFacet{
 				Text: "www.techdirt.com…",
 				URL:  pstr("https://www.techdirt.com/"),
 			},

automod/rules/nostr.go

···
 
 	appbsky "github.com/bluesky-social/indigo/api/bsky"
 	"github.com/bluesky-social/indigo/automod"
+	"github.com/bluesky-social/indigo/automod/helpers"
 )
 
 var _ automod.PostRuleFunc = NostrSpamPostRule
 
 // looks for new accounts, which frequently post the same type of content
 func NostrSpamPostRule(c *automod.RecordContext, post *appbsky.FeedPost) error {
-	if c.Account.Identity == nil || !AccountIsYoungerThan(&c.AccountContext, 2*24*time.Hour) {
+	if c.Account.Identity == nil || !helpers.AccountIsYoungerThan(&c.AccountContext, 2*24*time.Hour) {
 		return nil
 	}
 

automod/rules/promo.go

···
 	appbsky "github.com/bluesky-social/indigo/api/bsky"
 	"github.com/bluesky-social/indigo/automod"
 	"github.com/bluesky-social/indigo/automod/countstore"
+	"github.com/bluesky-social/indigo/automod/helpers"
 )
 
 var _ automod.PostRuleFunc = AggressivePromotionRule
···
 //
 // this rule depends on ReplyCountPostRule() to set counts
 func AggressivePromotionRule(c *automod.RecordContext, post *appbsky.FeedPost) error {
-	if c.Account.Identity == nil || !AccountIsYoungerThan(&c.AccountContext, 7*24*time.Hour) {
+	if c.Account.Identity == nil || !helpers.AccountIsYoungerThan(&c.AccountContext, 7*24*time.Hour) {
 		return nil
 	}
-	if post.Reply == nil || IsSelfThread(c, post) {
+	if post.Reply == nil || helpers.IsSelfThread(c, post) {
 		return nil
 	}
 
-	allURLs := ExtractTextURLs(post.Text)
+	allURLs := helpers.ExtractTextURLs(post.Text)
 	if c.Account.Profile.Description != nil {
-		profileURLs := ExtractTextURLs(*c.Account.Profile.Description)
+		profileURLs := helpers.ExtractTextURLs(*c.Account.Profile.Description)
 		allURLs = append(allURLs, profileURLs...)
 	}
 	hasPromo := false

automod/rules/quick.go

···
 
 	appbsky "github.com/bluesky-social/indigo/api/bsky"
 	"github.com/bluesky-social/indigo/automod"
+	"github.com/bluesky-social/indigo/automod/helpers"
 )
 
 var botLinkStrings = []string{"ainna13762491", "LINK押して", "→ https://tiny", "⇒ http://tiny"}
···
 var _ automod.IdentityRuleFunc = NewAccountBotEmailRule
 
 func NewAccountBotEmailRule(c *automod.AccountContext) error {
-	if c.Account.Identity == nil || !AccountIsYoungerThan(c, 1*time.Hour) {
+	if c.Account.Identity == nil || !helpers.AccountIsYoungerThan(c, 1*time.Hour) {
 		return nil
 	}
 
···
 
 // looks for new accounts, which frequently post the same type of content
 func TrivialSpamPostRule(c *automod.RecordContext, post *appbsky.FeedPost) error {
-	if c.Account.Identity == nil || !AccountIsYoungerThan(&c.AccountContext, 8*24*time.Hour) {
+	if c.Account.Identity == nil || !helpers.AccountIsYoungerThan(&c.AccountContext, 8*24*time.Hour) {
 		return nil
 	}
 

automod/rules/replies.go

···
 	"github.com/bluesky-social/indigo/atproto/syntax"
 	"github.com/bluesky-social/indigo/automod"
 	"github.com/bluesky-social/indigo/automod/countstore"
+	"github.com/bluesky-social/indigo/automod/helpers"
 )
 
 var _ automod.PostRuleFunc = ReplyCountPostRule
 
 // does not count "self-replies" (direct to self, or in own post thread)
 func ReplyCountPostRule(c *automod.RecordContext, post *appbsky.FeedPost) error {
-	if post.Reply == nil || IsSelfThread(c, post) {
+	if post.Reply == nil || helpers.IsSelfThread(c, post) {
 		return nil
 	}
 
···
 //
 // There can be legitimate situations that trigger this rule, so in most situations should be a "report" not "label" action.
 func IdenticalReplyPostRule(c *automod.RecordContext, post *appbsky.FeedPost) error {
-	if post.Reply == nil || IsSelfThread(c, post) {
+	if post.Reply == nil || helpers.IsSelfThread(c, post) {
 		return nil
 	}
 
···
 	if utf8.RuneCountInString(post.Text) <= 10 {
 		return nil
 	}
-	if AccountIsOlderThan(&c.AccountContext, 14*24*time.Hour) {
+	if helpers.AccountIsOlderThan(&c.AccountContext, 14*24*time.Hour) {
 		return nil
 	}
 
 	// don't count if there is a follow-back relationship
-	if ParentOrRootIsFollower(c, post) {
+	if helpers.ParentOrRootIsFollower(c, post) {
 		return nil
 	}
 
 	// increment before read. use a specific period (IncrementPeriod()) to reduce the number of counters (one per unique post text)
 	period := countstore.PeriodDay
-	bucket := c.Account.Identity.DID.String() + "/" + HashOfString(post.Text)
+	bucket := c.Account.Identity.DID.String() + "/" + helpers.HashOfString(post.Text)
 	c.IncrementPeriod("reply-text", bucket, period)
 
 	count := c.GetCount("reply-text", bucket, period)
···
 var _ automod.PostRuleFunc = IdenticalReplyPostSameParentRule
 
 func IdenticalReplyPostSameParentRule(c *automod.RecordContext, post *appbsky.FeedPost) error {
-	if post.Reply == nil || IsSelfThread(c, post) {
+	if post.Reply == nil || helpers.IsSelfThread(c, post) {
 		return nil
 	}
 
-	if ParentOrRootIsFollower(c, post) {
+	if helpers.ParentOrRootIsFollower(c, post) {
 		return nil
 	}
 
 	postCount := c.Account.PostsCount
-	if AccountIsOlderThan(&c.AccountContext, identicalReplySameParentMaxAge) || postCount >= identicalReplySameParentMaxPosts {
+	if helpers.AccountIsOlderThan(&c.AccountContext, identicalReplySameParentMaxAge) || postCount >= identicalReplySameParentMaxPosts {
 		return nil
 	}
 
 	period := countstore.PeriodHour
-	bucket := c.Account.Identity.DID.String() + "/" + post.Reply.Parent.Uri + "/" + HashOfString(post.Text)
+	bucket := c.Account.Identity.DID.String() + "/" + post.Reply.Parent.Uri + "/" + helpers.HashOfString(post.Text)
 	c.IncrementPeriod("reply-text-same-post", bucket, period)
 
 	count := c.GetCount("reply-text-same-post", bucket, period)
···
 
 func YoungAccountDistinctRepliesRule(c *automod.RecordContext, post *appbsky.FeedPost) error {
 	// only replies, and skip self-replies (eg, threads)
-	if post.Reply == nil || IsSelfThread(c, post) {
+	if post.Reply == nil || helpers.IsSelfThread(c, post) {
 		return nil
 	}
 
···
 	if utf8.RuneCountInString(post.Text) <= 10 {
 		return nil
 	}
-	if AccountIsOlderThan(&c.AccountContext, 14*24*time.Hour) {
+	if helpers.AccountIsOlderThan(&c.AccountContext, 14*24*time.Hour) {
 		return nil
 	}
 
 	// don't count if there is a follow-back relationship
-	if ParentOrRootIsFollower(c, post) {
+	if helpers.ParentOrRootIsFollower(c, post) {
 		return nil
 	}
 

automod/rules/reposts.go

···
 
 	"github.com/bluesky-social/indigo/automod"
 	"github.com/bluesky-social/indigo/automod/countstore"
+	"github.com/bluesky-social/indigo/automod/helpers"
 )
 
 var dailyRepostThresholdWithoutPost = 30
···
 // looks for accounts which do frequent reposts
 func TooManyRepostRule(c *automod.RecordContext) error {
 	// Don't bother checking reposts from accounts older than 30 days
-	if c.Account.Identity == nil || !AccountIsYoungerThan(&c.AccountContext, 30*24*time.Hour) {
+	if c.Account.Identity == nil || !helpers.AccountIsYoungerThan(&c.AccountContext, 30*24*time.Hour) {
 		return nil
 	}
 

automod/visual/hiveai_rule.go

···
 	"time"
 
 	"github.com/bluesky-social/indigo/automod"
-	"github.com/bluesky-social/indigo/automod/rules"
+	"github.com/bluesky-social/indigo/automod/helpers"
 	lexutil "github.com/bluesky-social/indigo/lex/util"
 )
 
···
 
 	for _, l := range labels {
 		// NOTE: experimenting with profile reporting for new accounts
-		if l == "sexual" && c.RecordOp.Collection.String() == "app.bsky.actor.profile" && rules.AccountIsYoungerThan(&c.AccountContext, 2*24*time.Hour) {
+		if l == "sexual" && c.RecordOp.Collection.String() == "app.bsky.actor.profile" && helpers.AccountIsYoungerThan(&c.AccountContext, 2*24*time.Hour) {
 			c.ReportRecord(automod.ReportReasonSexual, "possible sexual profile (not labeled yet)")
 			c.Logger.Info("skipping record label", "label", l, "reason", "sexual-profile-experiment")
 		} else {