feat: parse action tags @action from title

- action tags start with @ instead of # (example: @ArchiveBox)

Author: blob42

hooks/marktab.go

@@ -26,7 +26,6 @@ import (
 	"fmt"
 	"os"
 	"os/exec"
-	"slices"
 	"strings"
 	"time"
 
@@ -40,12 +39,6 @@ const (
 	ArchiveBoxTrigger = "@archivebox"
 )
 
-var (
-	BuiltinTriggers = []string{
-		ArchiveBoxTrigger,
-	}
-)
-
 // MarkTab represents a collection of rules defined in the marktab file as lines.
 type MarkTab struct {
 	Rules []Rule // Rules contains all the parsed rules from the marktab file.
@@ -99,11 +92,6 @@ func processMtabHook(bk *gosuki.Bookmark) error {
 
 			runID := utils.GenStringID(4)
 
-			// cleanout tags from builtin triggers
-			bk.Tags = slices.DeleteFunc(bk.Tags, func(in string) bool {
-				return slices.Contains(BuiltinTriggers, in)
-			})
-
 			log.Debug(
 				"run marktab",
 				"id",

pkg/parsing/parsetags_test.go

@@ -76,6 +76,20 @@ func TestParseTags(t *testing.T) {
 			expectedTags: []string{"existing", "newtag"},
 			expectError:  false,
 		},
+		{
+			name:         "Appending action to existing tags",
+			title:        "@action",
+			initialTags:  []string{"existing"},
+			expectedTags: []string{"existing", "@action"},
+			expectError:  false,
+		},
+		{
+			name:         "Valid action tags in node title",
+			title:        "This is a @action and #example",
+			initialTags:  nil,
+			expectedTags: []string{"example", "@action"},
+			expectError:  false,
+		},
 	}
 
 	for _, tt := range tests {

pkg/parsing/tags.go

@@ -44,8 +44,12 @@ const (
 	//this is a end of sentence #tag
 	// ReTags = `\B#(?P<tag>\w+\.?\w+)`
 	ReTags = `#(?P<tag>[a-zA-Z0-9_.-]+)`
+
 	// #tag:notify
 	ReNotify = `\b(?P<tag>[a-zA-Z0-9_.-]+):notify`
+
+	// Action tags start with @, the regex includes the @ sign
+	ReActionTag = `@(?P<tag>[a-zA-Z0-9_.-]+)`
 )
 
 var log = logging.GetLogger("parse")
@@ -54,40 +58,61 @@ func stripHashTag(s string) string {
 	return regexp.MustCompile(ReTags).ReplaceAllString(s, "")
 }
 
+// compelte this function
+func stripActionTags(s string) string {
+	return regexp.MustCompile(ReActionTag).ReplaceAllString(s, "")
+}
+
 // parseTags is a [gosuki.Hook] that extracts tags like #tag from the title of
 // the bookmark or node.
 // It takes an item of type *tree.Node or *gosuki.Bookmark, extracts all tags
 // matching the regex pattern defined in ReTags, appends them to the item's Tags
 // field, and removes the matched tags from the title. If the item is of an
 // unsupported type, it returns an error.
 func parseTags(item any) error {
-	var regex = regexp.MustCompile(ReTags)
+	tagRe := regexp.MustCompile(ReTags)
+	actionTagRe := regexp.MustCompile(ReActionTag)
 	switch v := item.(type) {
 	case *tree.Node:
 		if v.Tags == nil {
 			v.Tags = []string{}
 		}
-		processTags(regex, &v.Title, &v.Tags)
+		processTags(tagRe, &v.Title, &v.Tags, false)
+		v.Title = stripHashTag(v.Title)
+		processTags(actionTagRe, &v.Title, &v.Tags, true)
+		v.Title = stripActionTags(v.Title)
 	case *gosuki.Bookmark:
 		if v.Tags == nil {
 			v.Tags = []string{}
 		}
-		processTags(regex, &v.Title, &v.Tags)
+		processTags(tagRe, &v.Title, &v.Tags, false)
+		v.Title = stripHashTag(v.Title)
+		processTags(actionTagRe, &v.Title, &v.Tags, true)
+		v.Title = stripActionTags(v.Title)
 	default:
 		return fmt.Errorf("unsupported type")
 	}
 	return nil
 }
 
-func processTags(regex *regexp.Regexp, title *string, tags *[]string) {
+func processTags(
+	regex *regexp.Regexp,
+	title *string,
+	tags *[]string,
+	withSymbol bool,
+) {
+
 	matches := regex.FindAllStringSubmatch(*title, -1)
 	for _, m := range matches {
-		*tags = append(*tags, m[1])
+		if withSymbol {
+			*tags = append(*tags, m[0])
+		} else {
+			*tags = append(*tags, m[1])
+		}
 	}
 	if len(*tags) > 0 {
 		log.Tracef("[hook] found following tags: %s", *tags)
 	}
-	*title = stripHashTag(*title)
 }
 
 func ParseNodeTags(n *tree.Node) error {