refactor: replace explicit fields with tag-based property system

cmd/alias.go

@@ -12,46 +12,38 @@ import (
 var aliasList bool
 
 var aliasCmd = &cobra.Command{
-	Use:   "alias [name] [command]",
-	Short: "Manage aliases",
-	Args:  cobra.MaximumNArgs(2),
+	Use: "alias [name] [command]", Short: "Manage aliases", Args: cobra.MaximumNArgs(2),
 	Run: func(cmd *cobra.Command, args []string) {
 		d, err := db.GetDB()
 		if err != nil {
 			fmt.Fprintln(os.Stderr, err)
 			return
 		}
-		if aliasList {
-			aliases, err := d.ListAliases()
-			if err != nil {
-				return
+		w := cmd.OutOrStdout()
+
+		if aliasList || len(args) == 0 {
+			if aliases, err := d.ListAliases(); err == nil {
+				output.PrintAliases(w, aliases, jsonFlag)
 			}
-			output.PrintAliases(cmd.OutOrStdout(), aliases, jsonFlag)
-			return
-		}
-		if len(args) == 0 {
-			aliases, _ := d.ListAliases()
-			output.PrintAliases(cmd.OutOrStdout(), aliases, jsonFlag)
 			return
 		}
 		if len(args) == 1 {
-			a, err := d.GetAlias(args[0])
-			if err != nil {
-				fmt.Fprintln(os.Stderr, "  alias not found:", args[0])
-				return
+			if a, err := d.GetAlias(args[0]); err != nil {
+				fmt.Fprintln(os.Stderr, "alias not found:", args[0])
+			} else {
+				fmt.Println(a.Command)
 			}
-			fmt.Println(a.Command)
 			return
 		}
 		if err := d.SetAlias(args[0], args[1]); err != nil {
-			fmt.Fprintln(os.Stderr, "  failed to set alias:", err)
-			return
+			fmt.Fprintln(os.Stderr, "failed to set alias:", err)
+		} else {
+			output.PrintAction(w, "Alias set", args[0], false)
 		}
-		output.PrintSuccess(cmd.OutOrStdout(), "Alias '%s' set", args[0])
 	},
 }
 
 func init() {
 	rootCmd.AddCommand(aliasCmd)
-	aliasCmd.Flags().BoolVar(&aliasList, "list", false, "list all aliases")
+	aliasCmd.Flags().BoolVar(&aliasList, "list", false, "")
 }

cmd/create.go

@@ -6,63 +6,61 @@ import (
 	"axolotl/output"
 	"fmt"
 	"os"
+	"slices"
+	"strings"
 
 	"github.com/spf13/cobra"
 )
 
-var createType, createStatus, createPrio, createNamespace string = "issue", "open", "", ""
-var createDue, createContent string
-var createTags, createRels []string
+var cDue, cContent, cDummy string
+var cTags, cRels []string
 
 var createCmd = &cobra.Command{
-	Use:   "create <title>",
-	Short: "Create a new node",
-	Args:  cobra.ExactArgs(1),
+	Use: "create <title>", Short: "Create a new node", Args: cobra.ExactArgs(1),
 	Run: func(cmd *cobra.Command, args []string) {
 		d, err := db.GetDB()
 		if err != nil {
 			fmt.Fprintln(os.Stderr, err)
 			return
 		}
-		if createType == "issue" && createStatus == "" {
-			createStatus = "open"
+
+		if !slices.ContainsFunc(cTags, func(e string) bool { return strings.HasPrefix(e, "_type::") }) {
+			cTags = append(cTags, "_type::issue")
 		}
+		if slices.Contains(cTags, "_type::issue") && !slices.ContainsFunc(cTags, func(e string) bool { return strings.HasPrefix(e, "_status::") }) {
+			cTags = append(cTags, "_status::open")
+		}
+		if !slices.ContainsFunc(cTags, func(e string) bool { return strings.HasPrefix(e, "_namespace::") }) {
+			cTags = append(cTags, "_namespace::" + db.GetCurrentUser())
+		}
+
 		rels := make(map[models.RelType][]string)
-		for _, r := range createRels {
-			relType, target, err := db.ParseRelFlag(r)
+		for _, r := range cRels {
+			rt, tgt, err := db.ParseRelFlag(r)
 			if err != nil {
 				fmt.Fprintln(os.Stderr, err)
 				return
 			}
-			rels[relType] = append(rels[relType], target)
+			rels[rt] = append(rels[rt], tgt)
 		}
-		n, err := d.CreateNode(db.CreateParams{
-			Title:     args[0],
-			Content:   createContent,
-			DueDate:   createDue,
-			Type:      createType,
-			Status:    createStatus,
-			Priority:  createPrio,
-			Namespace: createNamespace,
-			Tags:      createTags,
-			Rels:      rels,
-		})
-		if err != nil {
+
+		if n, err := d.CreateNode(db.CreateParams{Title: args[0], Content: cContent, DueDate: cDue, Tags: cTags, Rels: rels}); err != nil {
 			fmt.Fprintln(os.Stderr, "failed to create:", err)
-			return
+		} else {
+			output.PrintNode(cmd.OutOrStdout(), n, jsonFlag)
 		}
-		output.PrintNode(cmd.OutOrStdout(), n, jsonFlag)
 	},
 }
 
 func init() {
 	rootCmd.AddCommand(createCmd)
-	createCmd.Flags().StringVar(&createType, "type", "issue", "node type (issue, note, user, namespace)")
-	createCmd.Flags().StringVar(&createStatus, "status", "", "status (open, done)")
-	createCmd.Flags().StringVar(&createPrio, "prio", "", "priority (high, medium, low)")
-	createCmd.Flags().StringVar(&createNamespace, "namespace", "", "namespace")
-	createCmd.Flags().StringVar(&createDue, "due", "", "due date")
-	createCmd.Flags().StringVar(&createContent, "content", "", "content")
-	createCmd.Flags().StringArrayVar(&createTags, "tag", nil, "tags (repeatable)")
-	createCmd.Flags().StringArrayVar(&createRels, "rel", nil, "relations (type:id, repeatable)")
+	f := createCmd.Flags()
+	f.StringVar(&cDummy, "type", "issue", "")
+	f.StringVar(&cDummy, "status", "", "")
+	f.StringVar(&cDummy, "prio", "", "")
+	f.StringVar(&cDummy, "namespace", "", "")
+	f.StringVar(&cDue, "due", "", "")
+	f.StringVar(&cContent, "content", "", "")
+	f.StringArrayVar(&cTags, "tag", nil, "")
+	f.StringArrayVar(&cRels, "rel", nil, "")
 }

cmd/delete.go

@@ -11,43 +11,39 @@ import (
 	"github.com/spf13/cobra"
 )
 
-var deleteForce bool
-
+var dForce bool
 var deleteCmd = &cobra.Command{
-	Use:   "delete <id>",
-	Short: "Delete a node",
-	Args:  cobra.ExactArgs(1),
+	Use: "delete <id>", Short: "Delete a node", Args: cobra.ExactArgs(1),
 	Run: func(cmd *cobra.Command, args []string) {
 		d, err := db.GetDB()
 		if err != nil {
 			fmt.Fprintln(os.Stderr, err)
 			return
 		}
-		id := args[0]
-		n, err := d.NodeByID(id)
+		n, err := d.NodeByID(args[0])
 		if err != nil {
-			fmt.Fprintln(os.Stderr, "  node not found:", id)
+			fmt.Fprintln(os.Stderr, "  node not found:", args[0])
 			return
 		}
-		if !deleteForce {
-			fmt.Printf("  Delete %s '%s'? [y/N]: ", n.GetType(), n.Title)
-			reader := bufio.NewReader(os.Stdin)
-			resp, _ := reader.ReadString('\n')
-			resp = strings.TrimSpace(strings.ToLower(resp))
-			if resp != "y" && resp != "yes" {
-				fmt.Println("  Cancelled.")
+
+		if !dForce {
+			fmt.Printf("Delete %s '%s'? [y/N]: ", n.GetProperty("type"), n.Title)
+			r, _ := bufio.NewReader(os.Stdin).ReadString('\n')
+			if r = strings.TrimSpace(strings.ToLower(r)); r != "y" && r != "yes" {
+				fmt.Println("Cancelled.")
 				return
 			}
 		}
-		if err := d.DeleteNode(id); err != nil {
-			fmt.Fprintln(os.Stderr, "  failed to delete:", err)
-			return
+
+		if err := d.DeleteNode(args[0]); err != nil {
+			fmt.Fprintln(os.Stderr, "failed to delete: ", err)
+		} else {
+			output.PrintAction(cmd.OutOrStdout(), "Deleted", args[0], true)
 		}
-		output.PrintDeleted(cmd.OutOrStdout(), id)
 	},
 }
 
 func init() {
 	rootCmd.AddCommand(deleteCmd)
-	deleteCmd.Flags().BoolVarP(&deleteForce, "force", "f", false, "skip confirmation")
+	deleteCmd.Flags().BoolVarP(&dForce, "force", "f", false, "")
 }

cmd/edit.go

@@ -11,21 +11,19 @@ import (
 )
 
 var editCmd = &cobra.Command{
-	Use:   "edit <id>",
-	Short: "Edit node content in $EDITOR",
-	Args:  cobra.ExactArgs(1),
+	Use: "edit <id>", Short: "Edit node content in $EDITOR", Args: cobra.ExactArgs(1),
 	Run: func(cmd *cobra.Command, args []string) {
 		d, err := db.GetDB()
 		if err != nil {
 			fmt.Fprintln(os.Stderr, err)
 			return
 		}
-		id := args[0]
-		n, err := d.NodeByID(id)
+		n, err := d.NodeByID(args[0])
 		if err != nil {
-			fmt.Fprintln(os.Stderr, "node not found:", id)
+			fmt.Fprintln(os.Stderr, "node not found:", args[0])
 			return
 		}
+
 		tmp, err := os.CreateTemp("", "ax-*.md")
 		if err != nil {
 			fmt.Fprintln(os.Stderr, "failed to create temp file:", err)
@@ -40,24 +38,22 @@ var editCmd = &cobra.Command{
 			editor = "vi"
 		}
 		c := exec.Command(editor, tmp.Name())
-		c.Stdin = os.Stdin
-		c.Stdout = os.Stdout
-		c.Stderr = os.Stderr
+		c.Stdin, c.Stdout, c.Stderr = os.Stdin, os.Stdout, os.Stderr
 		if err := c.Run(); err != nil {
 			fmt.Fprintln(os.Stderr, "editor failed:", err)
 			return
 		}
-		content, err := os.ReadFile(tmp.Name())
-		if err != nil {
+
+		if content, err := os.ReadFile(tmp.Name()); err == nil {
+			if err := d.UpdateNode(args[0], db.UpdateParams{Content: string(content)}); err != nil {
+				fmt.Fprintln(os.Stderr, "failed to update:", err)
+				return
+			}
+			n, _ = d.NodeByID(args[0])
+			output.PrintNode(cmd.OutOrStdout(), n, jsonFlag)
+		} else {
 			fmt.Fprintln(os.Stderr, "failed to read temp file:", err)
-			return
 		}
-		if err := d.UpdateNode(id, db.UpdateParams{Content: string(content)}); err != nil {
-			fmt.Fprintln(os.Stderr, "failed to update:", err)
-			return
-		}
-		n, _ = d.NodeByID(id)
-		output.PrintNode(cmd.OutOrStdout(), n, jsonFlag)
 	},
 }
 

cmd/inbox.go

@@ -3,23 +3,23 @@ package cmd
 import (
 	"axolotl/db"
 	"axolotl/output"
+	"fmt"
+	"os"
 
 	"github.com/spf13/cobra"
 )
 
 var inboxCmd = &cobra.Command{
-	Use:   "inbox",
-	Short: "Show your inbox",
+	Use: "inbox", Short: "Show your inbox",
 	Run: func(cmd *cobra.Command, args []string) {
 		d, err := db.GetDB()
-		user := db.GetCurrentUser()
-		nodes, err := d.ListNodes(db.ListFilter{
-			Inbox: user,
-		})
 		if err != nil {
+			fmt.Fprintln(os.Stderr, err)
 			return
 		}
-		output.PrintNodes(cmd.OutOrStdout(), nodes, jsonFlag)
+		if nodes, err := d.ListNodes(db.ListFilter{TagPrefixes: []string{"_inbox::" + db.GetCurrentUser()}}); err == nil {
+			output.PrintNodes(cmd.OutOrStdout(), nodes, jsonFlag)
+		}
 	},
 }
 

cmd/init.go

@@ -11,28 +11,23 @@ import (
 )
 
 var initCmd = &cobra.Command{
-	Use:   "init [path]",
-	Short: "Initialize a new database",
-	Args:  cobra.MaximumNArgs(1),
+	Use: "init [path]", Short: "Initialize a new database", Args: cobra.MaximumNArgs(1),
 	Run: func(cmd *cobra.Command, args []string) {
-		path := "."
+		p := "."
 		if len(args) > 0 {
-			path = args[0]
+			p = args[0]
 		}
-		dbPath := filepath.Join(path, ".ax.db")
+		dbPath := filepath.Join(p, ".ax.db")
 		if _, err := os.Stat(dbPath); err == nil {
 			fmt.Fprintln(os.Stderr, "database already exists:", dbPath)
 			os.Exit(1)
 		}
-		err := db.Init(dbPath)
-		if err != nil {
+		if err := db.Init(dbPath); err != nil {
 			fmt.Fprintln(os.Stderr, "failed to initialize:", err)
 			os.Exit(1)
 		}
-		output.PrintCreated(cmd.OutOrStdout(), dbPath)
+		output.PrintAction(cmd.OutOrStdout(), "Created", dbPath, false)
 	},
 }
 
-func init() {
-	rootCmd.AddCommand(initCmd)
-}
+func init() { rootCmd.AddCommand(initCmd) }

cmd/list.go

@@ -9,40 +9,32 @@ import (
 	"github.com/spf13/cobra"
 )
 
-var listType, listStatus, listPrio, listNamespace, listTag, listInbox, listAssignee string
+var lDummy, lAssignee string
+var lTags []string
 
 var listCmd = &cobra.Command{
-	Use:   "list",
-	Short: "List nodes",
+	Use: "list", Short: "List nodes",
 	Run: func(cmd *cobra.Command, args []string) {
 		d, err := db.GetDB()
 		if err != nil {
 			fmt.Fprintln(os.Stderr, err)
 			return
 		}
-		nodes, err := d.ListNodes(db.ListFilter{
-			Type:      listType,
-			Status:    listStatus,
-			Priority:  listPrio,
-			Namespace: listNamespace,
-			Tag:       listTag,
-			Inbox:     listInbox,
-			Assignee:  listAssignee,
-		})
-		if err != nil {
-			return
+		if nodes, err := d.ListNodes(db.ListFilter{TagPrefixes: lTags, Assignee: lAssignee}); err == nil {
+			output.PrintNodes(cmd.OutOrStdout(), nodes, jsonFlag)
+		} else {
+			fmt.Fprintln(os.Stderr, "err: %v", err)
 		}
-		output.PrintNodes(cmd.OutOrStdout(), nodes, jsonFlag)
 	},
 }
 
 func init() {
 	rootCmd.AddCommand(listCmd)
-	listCmd.Flags().StringVar(&listType, "type", "", "filter by type")
-	listCmd.Flags().StringVar(&listStatus, "status", "", "filter by status")
-	listCmd.Flags().StringVar(&listPrio, "prio", "", "filter by priority")
-	listCmd.Flags().StringVar(&listNamespace, "namespace", "", "filter by namespace")
-	listCmd.Flags().StringVar(&listTag, "tag", "", "filter by tag")
-	listCmd.Flags().StringVar(&listInbox, "inbox", "", "filter by inbox user")
-	listCmd.Flags().StringVar(&listAssignee, "assignee", "", "filter by assignee")
+	f := listCmd.Flags()
+	f.StringVar(&lDummy, "type", "", "")
+	f.StringVar(&lDummy, "status", "", "")
+	f.StringVar(&lDummy, "prio", "", "")
+	f.StringVar(&lDummy, "namespace", "", "")
+	f.StringVar(&lAssignee, "assignee", "", "")
+	f.StringArrayVar(&lTags, "tag", nil, "")
 }

cmd/root.go

@@ -2,23 +2,46 @@ package cmd
 
 import (
 	"os"
+	"strings"
 
 	"github.com/spf13/cobra"
 )
 
 var jsonFlag bool
-
-var rootCmd = &cobra.Command{
-	Use:   "ax",
-	Short: "The axolotl issue tracker",
-}
+var rootCmd = &cobra.Command{Use: "ax", Short: "The axolotl issue tracker"}
 
 func Execute() {
+	rootCmd.SetArgs(transformArgs(os.Args[1:]))
 	if err := rootCmd.Execute(); err != nil {
 		os.Exit(1)
 	}
 }
 
-func init() {
-	rootCmd.PersistentFlags().BoolVar(&jsonFlag, "json", false, "output as JSON")
+func transformArgs(args []string) []string {
+	aliases := map[string]string{
+		"--status":    "_status",
+		"--prio":      "_prio",
+		"--type":      "_type",
+		"--namespace": "_namespace",
+	}
+	result := []string{}
+
+	for i := 0; i < len(args); i++ {
+		if idx := strings.Index(args[i], "="); idx != -1 {
+			if prop, ok := aliases[args[i][:idx]]; ok {
+				result = append(result, "--tag", prop+"::"+args[i][idx+1:])
+				continue
+			}
+		}
+		if prop, ok := aliases[args[i]]; ok && i+1 < len(args) {
+			result, i = append(result, "--tag", prop+"::"+args[i+1]), i+1
+			continue
+		}
+		result = append(result, args[i])
+	}
+	return result
+}
+
+func init() {
+	rootCmd.PersistentFlags().BoolVar(&jsonFlag, "json", false, "")
 }

cmd/show.go

@@ -10,21 +10,18 @@ import (
 )
 
 var showCmd = &cobra.Command{
-	Use:   "show <id>",
-	Short: "Show node details",
-	Args:  cobra.ExactArgs(1),
+	Use: "show <id>", Short: "Show node details", Args: cobra.ExactArgs(1),
 	Run: func(cmd *cobra.Command, args []string) {
 		d, err := db.GetDB()
 		if err != nil {
 			fmt.Fprintln(os.Stderr, err)
 			return
 		}
-		n, err := d.NodeByID(args[0])
-		if err != nil {
+		if n, err := d.NodeByID(args[0]); err == nil {
+			output.PrintNode(cmd.OutOrStdout(), n, jsonFlag)
+		} else {
 			fmt.Fprintln(os.Stderr, "node not found:", args[0])
-			return
 		}
-		output.PrintNode(cmd.OutOrStdout(), n, jsonFlag)
 	},
 }
 

cmd/update.go

@@ -6,45 +6,45 @@ import (
 	"axolotl/output"
 	"fmt"
 	"os"
+	"slices"
+	"strings"
 
 	"github.com/spf13/cobra"
 )
 
-var updateTitle, updateContent, updateStatus, updatePrio, updateDue string
-var updateClearDue bool
-var updateAddTags, updateRemoveTags, updateAddRels, updateRemoveRels []string
+var (
+	uTitle, uContent, uDue, dummy        string
+	uClearDue                            bool
+	uAddTags, uRmTags, uAddRels, uRmRels []string
+)
 
 var updateCmd = &cobra.Command{
-	Use:   "update <id>",
-	Short: "Update a node",
-	Args:  cobra.ExactArgs(1),
+	Use: "update <id>", Short: "Update a node", Args: cobra.ExactArgs(1),
 	Run: func(cmd *cobra.Command, args []string) {
 		d, err := db.GetDB()
 		if err != nil {
 			fmt.Fprintln(os.Stderr, err)
 			return
 		}
-		id := args[0]
-		addRels := make(map[models.RelType][]string)
-		removeRels := make(map[models.RelType][]string)
-		for _, r := range updateAddRels {
-			relType, target, err := db.ParseRelFlag(r)
-			if err != nil {
-				fmt.Fprintln(os.Stderr, err)
-				return
+		addRels, rmRels := make(map[models.RelType][]string), make(map[models.RelType][]string)
+
+		parseRel := func(src []string, dst map[models.RelType][]string) bool {
+			for _, r := range src {
+				rt, tgt, err := db.ParseRelFlag(r)
+				if err != nil {
+					fmt.Fprintln(os.Stderr, err)
+					return false
+				}
+				dst[rt] = append(dst[rt], tgt)
 			}
-			addRels[relType] = append(addRels[relType], target)
+			return true
 		}
-		for _, r := range updateRemoveRels {
-			relType, target, err := db.ParseRelFlag(r)
-			if err != nil {
-				fmt.Fprintln(os.Stderr, err)
-				return
-			}
-			removeRels[relType] = append(removeRels[relType], target)
+		if !parseRel(uAddRels, addRels) || !parseRel(uRmRels, rmRels) {
+			return
 		}
-		if updateStatus == "done" {
-			ok, blockers, err := d.CanClose(id)
+
+		if slices.Contains(uAddTags, "_status::done") {
+			ok, blockers, err := d.CanClose(args[0])
 			if err != nil {
 				fmt.Fprintln(os.Stderr, "failed to check blockers:", err)
 				return
@@ -53,42 +53,39 @@ var updateCmd = &cobra.Command{
 				fmt.Fprintf(os.Stderr, "cannot close: blocked by %v\n", blockers)
 				return
 			}
+			uRmTags = append(uRmTags, "_status::open")
+		} else if slices.Contains(uAddTags, "_status::open") {
+			uRmTags = append(uRmTags, "_status::done")
 		}
-		err = d.UpdateNode(id, db.UpdateParams{
-			Title:      updateTitle,
-			Content:    updateContent,
-			DueDate:    updateDue,
-			ClearDue:   updateClearDue,
-			Status:     updateStatus,
-			Priority:   updatePrio,
-			AddTags:    updateAddTags,
-			RemoveTags: updateRemoveTags,
-			AddRels:    addRels,
-			RemoveRels: removeRels,
-		})
-		if err != nil {
+		if slices.ContainsFunc(uAddTags, func(e string) bool { return strings.HasPrefix(e, "_prio") }) {
+			uRmTags = append(uRmTags, "_prio::low", "_prio::medium", "_prio::high")
+		}
+
+		uParams := db.UpdateParams{Title: uTitle, Content: uContent, DueDate: uDue, ClearDue: uClearDue,
+			AddTags: uAddTags, RemoveTags: uRmTags, AddRels: addRels, RemoveRels: rmRels}
+		if err := d.UpdateNode(args[0], uParams); err != nil {
 			fmt.Fprintln(os.Stderr, "failed to update:", err)
 			return
 		}
-		n, err := d.NodeByID(id)
-		if err != nil {
+		if n, err := d.NodeByID(args[0]); err == nil {
+			output.PrintNode(cmd.OutOrStdout(), n, jsonFlag)
+		} else {
 			fmt.Fprintln(os.Stderr, "failed to fetch node:", err)
-			return
 		}
-		output.PrintNode(cmd.OutOrStdout(), n, jsonFlag)
 	},
 }
 
 func init() {
 	rootCmd.AddCommand(updateCmd)
-	updateCmd.Flags().StringVar(&updateTitle, "title", "", "new title")
-	updateCmd.Flags().StringVar(&updateContent, "content", "", "new content")
-	updateCmd.Flags().StringVar(&updateStatus, "status", "", "status (open, done)")
-	updateCmd.Flags().StringVar(&updatePrio, "prio", "", "priority (high, medium, low)")
-	updateCmd.Flags().StringVar(&updateDue, "due", "", "due date")
-	updateCmd.Flags().BoolVar(&updateClearDue, "clear-due", false, "clear due date")
-	updateCmd.Flags().StringArrayVar(&updateAddTags, "tag", nil, "add tags (repeatable)")
-	updateCmd.Flags().StringArrayVar(&updateRemoveTags, "tag-remove", nil, "remove tags (repeatable)")
-	updateCmd.Flags().StringArrayVar(&updateAddRels, "rel", nil, "add relations (type:id, repeatable)")
-	updateCmd.Flags().StringArrayVar(&updateRemoveRels, "rel-remove", nil, "remove relations (type:id, repeatable)")
+	f := updateCmd.Flags()
+	f.StringVar(&uTitle, "title", "", "")
+	f.StringVar(&uContent, "content", "", "")
+	f.StringVar(&uDue, "due", "", "")
+	f.BoolVar(&uClearDue, "clear-due", false, "")
+	f.StringVar(&dummy, "status", "", "")
+	f.StringVar(&dummy, "prio", "", "")
+	f.StringArrayVar(&uAddTags, "tag", nil, "")
+	f.StringArrayVar(&uRmTags, "tag-remove", nil, "")
+	f.StringArrayVar(&uAddRels, "rel", nil, "")
+	f.StringArrayVar(&uRmRels, "rel-remove", nil, "")
 }

db/alias.go

@@ -2,35 +2,25 @@ package db
 
 import "errors"
 
-type Alias struct {
-	Name    string
-	Command string
-}
+type Alias struct{ Name, Command string }
 
-func (db *DB) GetAlias(name string) (*Alias, error) {
+func (db *DB) GetAlias(n string) (*Alias, error) {
 	a := &Alias{}
-	err := db.QueryRow("SELECT name, command FROM aliases WHERE name = ?", name).Scan(&a.Name, &a.Command)
-	if err != nil {
-		return nil, err
-	}
-	return a, nil
+	err := db.QueryRow("SELECT name, command FROM aliases WHERE name = ?", n).Scan(&a.Name, &a.Command)
+	return a, err
 }
 
-func (db *DB) SetAlias(name, command string) error {
-	_, err := db.Exec(
-		"INSERT INTO aliases (name, command) VALUES (?, ?) ON CONFLICT(name) DO UPDATE SET command = excluded.command",
-		name, command,
-	)
+func (db *DB) SetAlias(n, c string) error {
+	_, err := db.Exec("INSERT INTO aliases (name, command) VALUES (?, ?) ON CONFLICT(name) DO UPDATE SET command = excluded.command", n, c)
 	return err
 }
 
-func (db *DB) DeleteAlias(name string) error {
-	res, err := db.Exec("DELETE FROM aliases WHERE name = ?", name)
+func (db *DB) DeleteAlias(n string) error {
+	res, err := db.Exec("DELETE FROM aliases WHERE name = ?", n)
 	if err != nil {
 		return err
 	}
-	n, _ := res.RowsAffected()
-	if n == 0 {
+	if a, _ := res.RowsAffected(); a == 0 {
 		return errors.New("alias not found")
 	}
 	return nil
@@ -42,7 +32,6 @@ func (db *DB) ListAliases() ([]*Alias, error) {
 		return nil, err
 	}
 	defer rows.Close()
-
 	var aliases []*Alias
 	for rows.Next() {
 		a := &Alias{}

db/db.go

@@ -8,8 +8,6 @@ import (
 	"os/user"
 	"path/filepath"
 
-	"axolotl/models"
-
 	_ "modernc.org/sqlite"
 )
 
@@ -18,38 +16,16 @@ type DB struct {
 	path string
 }
 
-var database *DB
-var migrations = []string{
-	`CREATE TABLE IF NOT EXISTS nodes (
-		id TEXT PRIMARY KEY,
-		title TEXT NOT NULL,
-		content TEXT,
-		due_date TEXT,
-		created_at TEXT NOT NULL DEFAULT CURRENT_TIMESTAMP,
-		updated_at TEXT NOT NULL DEFAULT CURRENT_TIMESTAMP
-	)`,
-	`CREATE TABLE IF NOT EXISTS tags (
-		node_id TEXT NOT NULL,
-		tag TEXT NOT NULL,
-		PRIMARY KEY (node_id, tag),
-		FOREIGN KEY (node_id) REFERENCES nodes(id) ON DELETE CASCADE
-	)`,
-	`CREATE TABLE IF NOT EXISTS rels (
-		from_id TEXT NOT NULL,
-		to_id TEXT NOT NULL,
-		rel_type TEXT NOT NULL,
-		PRIMARY KEY (from_id, to_id, rel_type),
-		FOREIGN KEY (from_id) REFERENCES nodes(id) ON DELETE CASCADE,
-		FOREIGN KEY (to_id) REFERENCES nodes(id) ON DELETE CASCADE
-	)`,
-	`CREATE TABLE IF NOT EXISTS aliases (
-		name TEXT PRIMARY KEY,
-		command TEXT NOT NULL
-	)`,
-	`CREATE INDEX IF NOT EXISTS idx_tags_tag ON tags(tag)`,
-	`CREATE INDEX IF NOT EXISTS idx_rels_from ON rels(from_id)`,
-	`CREATE INDEX IF NOT EXISTS idx_rels_to ON rels(to_id)`,
-}
+var (
+	database   *DB
+	migrations = []string{
+		`CREATE TABLE IF NOT EXISTS nodes (id TEXT PRIMARY KEY, title TEXT NOT NULL, content TEXT, due_date TEXT, created_at TEXT NOT NULL DEFAULT CURRENT_TIMESTAMP, updated_at TEXT NOT NULL DEFAULT CURRENT_TIMESTAMP)`,
+		`CREATE TABLE IF NOT EXISTS tags (node_id TEXT NOT NULL, tag TEXT NOT NULL, PRIMARY KEY (node_id, tag), FOREIGN KEY (node_id) REFERENCES nodes(id) ON DELETE CASCADE)`,
+		`CREATE TABLE IF NOT EXISTS rels (from_id TEXT NOT NULL, to_id TEXT NOT NULL, rel_type TEXT NOT NULL, PRIMARY KEY (from_id, to_id, rel_type), FOREIGN KEY (from_id) REFERENCES nodes(id) ON DELETE CASCADE, FOREIGN KEY (to_id) REFERENCES nodes(id) ON DELETE CASCADE)`,
+		`CREATE TABLE IF NOT EXISTS aliases (name TEXT PRIMARY KEY, command TEXT NOT NULL)`,
+		`CREATE INDEX IF NOT EXISTS idx_tags_tag ON tags(tag)`, `CREATE INDEX IF NOT EXISTS idx_rels_from ON rels(from_id)`, `CREATE INDEX IF NOT EXISTS idx_rels_to ON rels(to_id)`,
+	}
+)
 
 func GetDB() (*DB, error) {
 	if database != nil {
@@ -60,25 +36,22 @@ func GetDB() (*DB, error) {
 		return nil, err
 	}
 	for {
-		path := filepath.Join(dir, ".ax.db")
-		if _, err := os.Stat(path); err == nil {
-			database, err = Open(path)
-			if err != nil {
+		if _, err := os.Stat(filepath.Join(dir, ".ax.db")); err == nil {
+			if database, err = Open(filepath.Join(dir, ".ax.db")); err != nil {
 				return nil, fmt.Errorf("failed to open database: %w", err)
 			}
 			return database, nil
 		}
-		parent := filepath.Dir(dir)
-		if parent == dir {
+		if parent := filepath.Dir(dir); parent == dir {
 			return nil, errors.New("no .ax.db found (run 'ax init' first)")
+		} else {
+			dir = parent
 		}
-		path = parent
 	}
 }
 
-func Init(path string) (error) {
-	dir := filepath.Dir(path)
-	if err := os.MkdirAll(dir, 0755); err != nil {
+func Init(path string) error {
+	if err := os.MkdirAll(filepath.Dir(path), 0755); err != nil {
 		return err
 	}
 	var err error
@@ -87,19 +60,16 @@ func Init(path string) (error) {
 }
 
 func Open(path string) (*DB, error) {
-	database, err := sql.Open("sqlite", path)
+	db, err := sql.Open("sqlite", path)
 	if err != nil {
 		return nil, err
 	}
-	database.Exec("PRAGMA journal_mode=WAL")
-	database.Exec("PRAGMA busy_timeout=5000")
-	database.Exec("PRAGMA foreign_keys=ON")
-	for _, m := range migrations {
-		if _, err := database.Exec(m); err != nil {
+	for _, q := range append([]string{"PRAGMA journal_mode=WAL", "PRAGMA busy_timeout=5000", "PRAGMA foreign_keys=ON"}, migrations...) {
+		if _, err := db.Exec(q); err != nil {
 			return nil, err
 		}
 	}
-	return &DB{DB: database, path: path}, nil
+	return &DB{DB: db, path: path}, nil
 }
 
 func GetCurrentUser() string {
@@ -111,44 +81,3 @@ func GetCurrentUser() string {
 	}
 	return "unknown"
 }
-
-func (db *DB) NodeExists(id string) (bool, error) {
-	var exists bool
-	err := db.QueryRow("SELECT EXISTS(SELECT 1 FROM nodes WHERE id = ?)", id).Scan(&exists)
-	return exists, err
-}
-
-func (db *DB) NodeByID(id string) (*models.Node, error) {
-	n := &models.Node{Relations: make(map[string][]string)}
-	err := db.QueryRow(
-		"SELECT id, title, COALESCE(content, ''), COALESCE(due_date, ''), created_at, updated_at FROM nodes WHERE id = ?",
-		id,
-	).Scan(&n.ID, &n.Title, &n.Content, &n.DueDate, &n.CreatedAt, &n.UpdatedAt)
-	if err != nil {
-		return nil, err
-	}
-
-	rows, err := db.Query("SELECT tag FROM tags WHERE node_id = ?", id)
-	if err != nil {
-		return nil, err
-	}
-	defer rows.Close()
-	for rows.Next() {
-		var tag string
-		rows.Scan(&tag)
-		n.Tags = append(n.Tags, tag)
-	}
-
-	rows, err = db.Query("SELECT to_id, rel_type FROM rels WHERE from_id = ?", id)
-	if err != nil {
-		return nil, err
-	}
-	defer rows.Close()
-	for rows.Next() {
-		var toID, relType string
-		rows.Scan(&toID, &relType)
-		n.Relations[relType] = append(n.Relations[relType], toID)
-	}
-
-	return n, nil
-}

db/node.go

@@ -10,37 +10,45 @@ import (
 	"time"
 )
 
-func generateID() string {
-	const chars = "abcdefghijklmnopqrstuvwxyz"
+func genID() string {
 	b := make([]byte, 5)
 	for i := range b {
-		b[i] = chars[rand.Intn(26)]
+		b[i] = "abcdefghijklmnopqrstuvwxyz"[rand.Intn(26)]
 	}
 	return string(b)
 }
 
+func ParseRelFlag(s string) (models.RelType, string, error) {
+	if p := strings.SplitN(s, ":", 2); len(p) == 2 {
+		return models.RelType(p[0]), p[1], nil
+	}
+	return "", "", fmt.Errorf("invalid relation format: %s (expected type:id)", s)
+}
+
 func (db *DB) generateUniqueID() string {
-	//TODO: Check if all ids are reserved
 	for {
-		id := generateID()
-		var exists bool
-		db.QueryRow("SELECT EXISTS(SELECT 1 FROM nodes WHERE id = ?)", id).Scan(&exists)
-		if !exists {
+		id := genID()
+		e, _ := db.NodeExists(id)
+		if !e {
 			return id
 		}
 	}
 }
 
 type CreateParams struct {
-	Title     string
-	Content   string
-	DueDate   string
-	Type      string
-	Status    string
-	Priority  string
-	Namespace string
-	Tags      []string
-	Rels      map[models.RelType][]string
+	Title, Content, DueDate string
+	Tags                    []string
+	Rels                    map[models.RelType][]string
+}
+type UpdateParams struct {
+	Title, Content, DueDate string
+	ClearDue                bool
+	AddTags, RemoveTags     []string
+	AddRels, RemoveRels     map[models.RelType][]string
+}
+type ListFilter struct {
+	TagPrefixes []string
+	Assignee    string
 }
 
 func (db *DB) CreateNode(p CreateParams) (*models.Node, error) {
@@ -49,78 +57,35 @@ func (db *DB) CreateNode(p CreateParams) (*models.Node, error) {
 		return nil, err
 	}
 	defer tx.Rollback()
+	now, id := time.Now().UTC().Format(time.RFC3339), db.generateUniqueID()
 
-	now := time.Now().UTC().Format(time.RFC3339)
-	id := db.generateUniqueID()
-
-	_, err = tx.Exec(
-		"INSERT INTO nodes (id, title, content, due_date, created_at, updated_at) VALUES (?, ?, ?, ?, ?, ?)",
-		id, p.Title, p.Content, p.DueDate, now, now,
-	)
+	_, err = tx.Exec("INSERT INTO nodes (id, title, content, due_date, created_at, updated_at) VALUES (?, ?, ?, ?, ?, ?)",
+		id, p.Title, p.Content, p.DueDate, now, now)
 	if err != nil {
 		return nil, err
 	}
-
-	tags := p.Tags
-	if p.Type != "" {
-		tags = append(tags, models.PropertyTag("type", p.Type))
-	} else {
-		tags = append(tags, models.PropertyTag("type", "issue"))
-	}
-	if p.Status != "" {
-		tags = append(tags, models.PropertyTag("status", p.Status))
-	}
-	if p.Priority != "" {
-		tags = append(tags, models.PropertyTag("prio", p.Priority))
-	}
-	ns := p.Namespace
-	if ns == "" {
-		ns = GetCurrentUser()
-	}
-	tags = append(tags, models.PropertyTag("namespace", ns))
-
-	for _, tag := range tags {
-		if _, err := tx.Exec("INSERT INTO tags (node_id, tag) VALUES (?, ?)", id, tag); err != nil {
+	for _, t := range append(p.Tags, parse.Mentions(p.Title+" "+p.Content)...) {
+		if !strings.HasPrefix(t, "_") && strings.HasPrefix(t, "@") {
+			if _, err = tx.Exec("INSERT INTO tags (node_id, tag) VALUES (?, ?)", id, "_inbox::"+t[1:]); err != nil {
+				return nil, err
+			}
+		} else if _, err := tx.Exec("INSERT INTO tags (node_id, tag) VALUES (?, ?)", id, t); err != nil {
 			return nil, err
 		}
 	}
-
-	for relType, targets := range p.Rels {
-		for _, target := range targets {
-			if _, err := tx.Exec(
-				"INSERT INTO rels (from_id, to_id, rel_type) VALUES (?, ?, ?)",
-				id, target, relType,
-			); err != nil {
+	for rt, tgts := range p.Rels {
+		for _, tgt := range tgts {
+			if _, err := tx.Exec("INSERT INTO rels (from_id, to_id, rel_type) VALUES (?, ?, ?)", id, tgt, rt); err != nil {
 				return nil, err
 			}
 		}
 	}
-
-	allText := p.Title + " " + p.Content
-	for _, u := range parse.Mentions(allText) {
-		tx.Exec("INSERT INTO tags (node_id, tag) VALUES (?, ?)", id, models.PropertyTag("inbox", u))
-	}
-
 	if err := tx.Commit(); err != nil {
 		return nil, err
 	}
-
 	return db.NodeByID(id)
 }
 
-type UpdateParams struct {
-	Title      string
-	Content    string
-	DueDate    string
-	ClearDue   bool
-	Status     string
-	Priority   string
-	AddTags    []string
-	RemoveTags []string
-	AddRels    map[models.RelType][]string
-	RemoveRels map[models.RelType][]string
-}
-
 func (db *DB) UpdateNode(id string, p UpdateParams) error {
 	tx, err := db.Begin()
 	if err != nil {
@@ -128,231 +93,197 @@ func (db *DB) UpdateNode(id string, p UpdateParams) error {
 	}
 	defer tx.Rollback()
 
-	now := time.Now().UTC().Format(time.RFC3339)
-	_, err = tx.Exec("UPDATE nodes SET updated_at = ? WHERE id = ?", now, id)
-	if err != nil {
+	upd := func(col, val string) error {
+		_, err := tx.Exec("UPDATE nodes SET "+col+" = ? WHERE id = ?", val, id)
 		return err
 	}
-
+	//TODO: does it make sense to check for emtpy sting? should it be possible to set the content to ""?
 	if p.Title != "" {
-		_, err = tx.Exec("UPDATE nodes SET title = ? WHERE id = ?", p.Title, id)
-		if err != nil {
+		if err := upd("title", p.Title); err != nil {
 			return err
 		}
 	}
 	if p.Content != "" {
-		_, err = tx.Exec("UPDATE nodes SET content = ? WHERE id = ?", p.Content, id)
-		if err != nil {
+		if err := upd("content", p.Content); err != nil {
 			return err
 		}
 	}
 	if p.DueDate != "" {
-		_, err = tx.Exec("UPDATE nodes SET due_date = ? WHERE id = ?", p.DueDate, id)
-		if err != nil {
+		if err := upd("due_date", p.DueDate); err != nil {
 			return err
 		}
 	}
 	if p.ClearDue {
-		_, err = tx.Exec("UPDATE nodes SET due_date = NULL WHERE id = ?", id)
-		if err != nil {
+		if _, err := tx.Exec("UPDATE nodes SET due_date = NULL WHERE id = ?", id); err != nil {
 			return err
 		}
 	}
 
-	for _, tag := range p.AddTags {
-		tx.Exec("INSERT OR IGNORE INTO tags (node_id, tag) VALUES (?, ?)", id, tag)
+	for _, t := range p.RemoveTags {
+		tx.Exec("DELETE FROM tags WHERE node_id = ? AND tag = ?", id, t)
 	}
-	for _, tag := range p.RemoveTags {
-		tx.Exec("DELETE FROM tags WHERE node_id = ? AND tag = ?", id, tag)
+	for _, t := range p.AddTags {
+		tx.Exec("INSERT OR IGNORE INTO tags (node_id, tag) VALUES (?, ?)", id, t)
 	}
-
-	if p.Status != "" {
-		tx.Exec("DELETE FROM tags WHERE node_id = ? AND tag LIKE '_status::%'", id)
-		tx.Exec("INSERT INTO tags (node_id, tag) VALUES (?, ?)", id, models.PropertyTag("status", p.Status))
-	}
-	if p.Priority != "" {
-		tx.Exec("DELETE FROM tags WHERE node_id = ? AND tag LIKE '_prio::%'", id)
-		tx.Exec("INSERT INTO tags (node_id, tag) VALUES (?, ?)", id, models.PropertyTag("prio", p.Priority))
-	}
-
-	for relType, targets := range p.AddRels {
-		for _, target := range targets {
-			tx.Exec("INSERT OR IGNORE INTO rels (from_id, to_id, rel_type) VALUES (?, ?, ?)", id, target, relType)
+	for rt, tgts := range p.RemoveRels {
+		for _, tgt := range tgts {
+			tx.Exec("DELETE FROM rels WHERE from_id = ? AND to_id = ? AND rel_type = ?", id, tgt, rt)
 		}
 	}
-	for relType, targets := range p.RemoveRels {
-		for _, target := range targets {
-			tx.Exec("DELETE FROM rels WHERE from_id = ? AND to_id = ? AND rel_type = ?", id, target, relType)
+	for rt, tgts := range p.AddRels {
+		for _, tgt := range tgts {
+			tx.Exec("INSERT OR IGNORE INTO rels (from_id, to_id, rel_type) VALUES (?, ?, ?)", id, tgt, rt)
 		}
 	}
 
+	if _, err = tx.Exec("UPDATE nodes SET updated_at = ? WHERE id = ?", time.Now().UTC().Format(time.RFC3339), id); err != nil {
+		return err
+	}
 	return tx.Commit()
 }
 
 func (db *DB) DeleteNode(id string) error {
+	//TODO: check if this delete propagates?
 	_, err := db.Exec("DELETE FROM nodes WHERE id = ?", id)
 	return err
 }
 
-type ListFilter struct {
-	Type      string
-	Status    string
-	Priority  string
-	Namespace string
-	Tag       string
-	Inbox     string
-	Assignee  string
+func (db *DB) NodeExists(id string) (bool, error) {
+	var e bool
+	err := db.QueryRow("SELECT EXISTS(SELECT 1 FROM nodes WHERE id = ?)", id).Scan(&e)
+	return e, err
+}
+
+func (db *DB) NodeByID(id string) (*models.Node, error) {
+	n := &models.Node{Relations: make(map[string][]string)}
+	q := db.QueryRow("SELECT id, title, COALESCE(content, ''), COALESCE(due_date, ''), created_at, updated_at FROM nodes WHERE id = ?", id)
+	if err := q.Scan(&n.ID, &n.Title, &n.Content, &n.DueDate, &n.CreatedAt, &n.UpdatedAt); err != nil {
+		return nil, err
+	}
+
+	if rows, err := db.Query("SELECT tag FROM tags WHERE node_id = ?", id); err == nil {
+		defer rows.Close()
+		for rows.Next() {
+			var tag string
+			rows.Scan(&tag)
+			n.Tags = append(n.Tags, tag)
+		}
+	} else {
+		return nil, err
+	}
+
+	if rows, err := db.Query("SELECT to_id, rel_type FROM rels WHERE from_id = ?", id); err == nil {
+		defer rows.Close()
+		for rows.Next() {
+			var toID, relType string
+			rows.Scan(&toID, &relType)
+			n.Relations[relType] = append(n.Relations[relType], toID)
+		}
+	} else {
+		return nil, err
+	}
+	return n, nil
 }
 
 func (db *DB) ListNodes(f ListFilter) ([]*models.Node, error) {
-	q := "SELECT DISTINCT n.id FROM nodes n"
-	args := []interface{}{}
-	joins := []string{}
-	conds := []string{}
+	q, args, joins, conds := "SELECT DISTINCT n.id FROM nodes n", []any{}, []string{}, []string{}
+	if len(f.TagPrefixes) == 0 {
+		f.TagPrefixes = append(f.TagPrefixes, "")
+	}
 
-	if f.Type != "" {
-		joins = append(joins, "JOIN tags t_type ON n.id = t_type.node_id")
-		conds = append(conds, "t_type.tag = ?")
-		args = append(args, models.PropertyTag("type", f.Type))
-	}
-	if f.Status != "" {
-		joins = append(joins, "JOIN tags t_status ON n.id = t_status.node_id")
-		conds = append(conds, "t_status.tag = ?")
-		args = append(args, models.PropertyTag("status", f.Status))
-	}
-	if f.Priority != "" {
-		joins = append(joins, "JOIN tags t_prio ON n.id = t_prio.node_id")
-		conds = append(conds, "t_prio.tag = ?")
-		args = append(args, models.PropertyTag("prio", f.Priority))
-	}
-	if f.Namespace != "" {
-		joins = append(joins, "JOIN tags t_ns ON n.id = t_ns.node_id")
-		conds = append(conds, "t_ns.tag = ?")
-		args = append(args, models.PropertyTag("namespace", f.Namespace))
-	}
-	if f.Tag != "" {
-		joins = append(joins, "JOIN tags t_tag ON n.id = t_tag.node_id")
-		conds = append(conds, "t_tag.tag = ?")
-		args = append(args, f.Tag)
-	}
-	if f.Inbox != "" {
-		joins = append(joins, "JOIN tags t_inbox ON n.id = t_inbox.node_id")
-		conds = append(conds, "t_inbox.tag = ?")
-		args = append(args, models.PropertyTag("inbox", f.Inbox))
+	joins = append(joins, "JOIN tags t_tag ON n.id = t_tag.node_id")
+	cond := ""
+	for _, t := range f.TagPrefixes {
+		cond += "t_tag.tag LIKE ? || '%' OR "
+		args = append(args, t)
 	}
+	conds = append(conds, "SUM(CASE WHEN "+cond[:len(cond)-4]+" THEN 1 ELSE 0 END) >= ?")
+	args = append(args, len(f.TagPrefixes))
+
 	if f.Assignee != "" {
-		joins = append(joins, "JOIN rels r_assign ON n.id = r_assign.from_id")
-		conds = append(conds, "r_assign.to_id = ? AND r_assign.rel_type = ?")
-		args = append(args, f.Assignee, models.RelAssignee)
+		joins, conds, args = append(joins, "JOIN rels r_assign ON n.id = r_assign.from_id"), append(conds, "r_assign.to_id = ? AND r_assign.rel_type = ?"), append(args, f.Assignee, models.RelAssignee)
 	}
 
 	if len(joins) > 0 {
-		q += " " + strings.Join(joins, " ")
+		q += " " + strings.Join(joins, " ") + " "
 	}
+	q += "GROUP BY n.id"
 	if len(conds) > 0 {
-		q += " WHERE " + strings.Join(conds, " AND ")
+		q += " HAVING " + strings.Join(conds, " AND ")
 	}
-	q += " ORDER BY n.created_at DESC"
 
-	rows, err := db.Query(q, args...)
+	rows, err := db.Query(q+" ORDER BY n.created_at DESC", args...)
 	if err != nil {
 		return nil, err
 	}
 	defer rows.Close()
-
 	var nodes []*models.Node
 	for rows.Next() {
 		var id string
 		if err := rows.Scan(&id); err != nil {
 			return nil, err
 		}
-		n, err := db.NodeByID(id)
-		if err != nil {
+		if n, err := db.NodeByID(id); err == nil {
+			nodes = append(nodes, n)
+		} else {
 			return nil, err
 		}
-		nodes = append(nodes, n)
 	}
 	return nodes, nil
 }
 
 func (db *DB) CanClose(id string) (bool, []string, error) {
-	rows, err := db.Query(
-		"SELECT to_id FROM rels WHERE from_id = ? AND rel_type = ?",
-		id, models.RelBlocks,
-	)
+	rows, err := db.Query("SELECT to_id FROM rels WHERE from_id = ? AND rel_type = ?", id, models.RelBlocks)
 	if err != nil {
 		return false, nil, err
 	}
 	defer rows.Close()
-
 	var blocking []string
 	for rows.Next() {
-		var blockerID string
-		if err := rows.Scan(&blockerID); err != nil {
+		var bID, tag string
+		if err := rows.Scan(&bID); err != nil {
 			return false, nil, err
 		}
-		var tag string
-		err := db.QueryRow(
-			"SELECT tag FROM tags WHERE node_id = ? AND tag LIKE '_status::%'",
-			blockerID,
-		).Scan(&tag)
-		if err == sql.ErrNoRows {
-			blocking = append(blocking, blockerID)
+		if err := db.QueryRow("SELECT tag FROM tags WHERE node_id = ? AND tag LIKE '_status::%'", bID).Scan(&tag); err == sql.ErrNoRows {
 			continue
-		}
-		if err != nil {
+		} else if err != nil {
 			return false, nil, err
 		}
 		if strings.HasSuffix(tag, "::open") {
-			blocking = append(blocking, blockerID)
+			blocking = append(blocking, bID)
 		}
 	}
 	return len(blocking) == 0, blocking, nil
 }
 
 func (db *DB) GetAllUsers() ([]string, error) {
-	rows, err := db.Query("SELECT n.id FROM nodes n JOIN tags t ON n.id = t.node_id WHERE t.tag = ?", models.PropertyTag("type", "user"))
+	//TODO: Seperate sql query for performance
+	nodes, err := db.ListNodes(ListFilter{TagPrefixes: []string{"_type::user"}})
 	if err != nil {
 		return nil, err
 	}
-	defer rows.Close()
-
-	var users []string
-	for rows.Next() {
-		var id string
-		rows.Scan(&id)
-		users = append(users, id)
+	users := make([]string, len(nodes))
+	for i, n := range nodes {
+		users[i] = n.ID
 	}
 	return users, nil
 }
 
 func (db *DB) GetSubtasks(parentID string) ([]*models.Node, error) {
-	rows, err := db.Query(
-		"SELECT to_id FROM rels WHERE from_id = ? AND rel_type = ?",
-		parentID, models.RelSubtask,
-	)
+	rows, err := db.Query("SELECT to_id FROM rels WHERE from_id = ? AND rel_type = ?", parentID, models.RelSubtask)
 	if err != nil {
 		return nil, err
 	}
 	defer rows.Close()
-
 	var nodes []*models.Node
 	for rows.Next() {
 		var id string
 		rows.Scan(&id)
-		n, err := db.NodeByID(id)
-		if err != nil {
+		if n, err := db.NodeByID(id); err == nil {
+			nodes = append(nodes, n)
+		} else {
 			return nil, err
 		}
-		nodes = append(nodes, n)
 	}
 	return nodes, nil
 }
-
-func ParseRelFlag(s string) (models.RelType, string, error) {
-	parts := strings.SplitN(s, ":", 2)
-	if len(parts) != 2 {
-		return "", "", fmt.Errorf("invalid relation format: %s (expected type:id)", s)
-	}
-	return models.RelType(parts[0]), parts[1], nil
-}

db/rel.go

@@ -2,56 +2,33 @@ package db
 
 import "axolotl/models"
 
-func (db *DB) AddRel(fromID, toID string, relType models.RelType) error {
-	_, err := db.Exec(
-		"INSERT OR IGNORE INTO rels (from_id, to_id, rel_type) VALUES (?, ?, ?)",
-		fromID, toID, relType,
-	)
+func (db *DB) AddRel(f, t string, r models.RelType) error {
+	_, err := db.Exec("INSERT OR IGNORE INTO rels (from_id, to_id, rel_type) VALUES (?, ?, ?)", f, t, r)
+	return err
+}
+func (db *DB) RemoveRel(f, t string, r models.RelType) error {
+	_, err := db.Exec("DELETE FROM rels WHERE from_id = ? AND to_id = ? AND rel_type = ?", f, t, r)
 	return err
 }
 
-func (db *DB) RemoveRel(fromID, toID string, relType models.RelType) error {
-	_, err := db.Exec(
-		"DELETE FROM rels WHERE from_id = ? AND to_id = ? AND rel_type = ?",
-		fromID, toID, relType,
-	)
-	return err
-}
-
-func (db *DB) GetRelated(id string, relType models.RelType) ([]string, error) {
-	rows, err := db.Query(
-		"SELECT to_id FROM rels WHERE from_id = ? AND rel_type = ?",
-		id, relType,
-	)
+func getIDs(db *DB, q, id string, r models.RelType) ([]string, error) {
+	rows, err := db.Query(q, id, r)
 	if err != nil {
 		return nil, err
 	}
 	defer rows.Close()
-
 	var ids []string
 	for rows.Next() {
-		var target string
-		rows.Scan(&target)
-		ids = append(ids, target)
+		var i string
+		rows.Scan(&i)
+		ids = append(ids, i)
 	}
 	return ids, nil
 }
 
-func (db *DB) GetIncomingRels(id string, relType models.RelType) ([]string, error) {
-	rows, err := db.Query(
-		"SELECT from_id FROM rels WHERE to_id = ? AND rel_type = ?",
-		id, relType,
-	)
-	if err != nil {
-		return nil, err
-	}
-	defer rows.Close()
-
-	var ids []string
-	for rows.Next() {
-		var source string
-		rows.Scan(&source)
-		ids = append(ids, source)
-	}
-	return ids, nil
+func (db *DB) GetRelated(id string, r models.RelType) ([]string, error) {
+	return getIDs(db, "SELECT to_id FROM rels WHERE from_id = ? AND rel_type = ?", id, r)
+}
+func (db *DB) GetIncomingRels(id string, r models.RelType) ([]string, error) {
+	return getIDs(db, "SELECT from_id FROM rels WHERE to_id = ? AND rel_type = ?", id, r)
 }

models/node.go

@@ -23,40 +23,13 @@ const (
 	RelAssignee RelType = "assignee"
 )
 
-func ParseTag(s string) (key, value string, isProperty bool) {
-	if strings.HasPrefix(s, "_") {
-		if parts := strings.SplitN(s[1:], "::", 2); len(parts) == 2 {
-			return parts[0], parts[1], true
-		}
-	}
-	return "", s, false
-}
-
-func PropertyTag(key, value string) string {
-	return "_" + key + "::" + value
-}
-
-func (n *Node) GetProperty(key string) string {
-	for _, tag := range n.Tags {
-		if k, v, ok := ParseTag(tag); ok && k == key {
-			return v
+func (n *Node) GetProperty(k string) string {
+	for _, t := range n.Tags {
+		if strings.HasPrefix(t, "_") {
+			if p := strings.SplitN(t[1:], "::", 2); len(p) == 2 && p[0] == k {
+				return p[1]
+			}
 		}
 	}
 	return ""
 }
-
-func (n *Node) GetType() string {
-	if t := n.GetProperty("type"); t != "" {
-		return t
-	}
-	return "issue"
-}
-
-func (n *Node) HasTag(tag string) bool {
-	for _, t := range n.Tags {
-		if t == tag {
-			return true
-		}
-	}
-	return false
-}

output/output.go

@@ -12,160 +12,106 @@ import (
 	"github.com/fatih/color"
 )
 
+type RenderMap map[string]struct {
+	s string
+	l string
+	c *color.Color
+}
+
 var (
-	idColor      = color.New(color.FgYellow)
-	titleColor   = color.New(color.FgWhite, color.Bold)
-	statusOpen   = color.New(color.FgYellow)
-	statusDone   = color.New(color.FgHiBlack)
-	prioHigh     = color.New(color.FgHiRed)
-	prioMedium   = color.New(color.FgYellow)
-	prioLow      = color.New(color.FgYellow, color.Faint)
-	tagColor     = color.New(color.FgCyan)
-	nsColor      = color.New(color.FgYellow)
-	dimColor     = color.New(color.FgHiBlack)
-	contentColor = color.New(color.FgWhite)
-	labelColor   = color.New(color.FgYellow)
-	typeIssue    = color.New(color.FgMagenta)
-	typeNote     = color.New(color.FgHiBlue)
-	typeUser     = color.New(color.FgHiGreen)
-	typeNs       = color.New(color.FgHiYellow)
+	cPrimary = color.New(color.FgCyan)
+	cSecond  = color.New(color.FgMagenta)
+	cDim     = color.New(color.FgHiBlack)
+	cText    = color.New(color.FgWhite)
+	cTitle   = color.New(color.FgWhite, color.Bold)
+	cGood    = color.New(color.FgGreen)
+	cWarn    = color.New(color.FgYellow)
+	cBad     = color.New(color.FgRed)
+
+	typeRM = RenderMap{
+		"issue":     {" ", "\uf188 issue", cSecond},
+		"note":      {"\uf15c", "\uf15c note", cPrimary},
+		"user":      {"\uf007", "\uf007 user", cGood},
+		"namespace": {"\uf07b", "\uf07b namespace", cWarn},
+		"":          {" ", "n/a", cDim},
+	}
+	statusRM = RenderMap{
+		"open": {"●", "● open", cPrimary},
+		"done": {"○", "○ done", cDim},
+		"":     {"—", "n/a", cDim},
+	}
+	prioRM = RenderMap{
+		"high":   {"\uf0e7", "high", cBad},
+		"medium": {"\uf0e7", "medium", cWarn},
+		"low":    {" ", "low", cDim},
+		"":       {" ", "n/a", cDim},
+	}
+	relIcons    = map[string]string{"blocks": "\uf068", "subtask": "\uf0da", "related": "\uf0c1", "assignee": "\uf007"}
+	prioRanks   = map[string]int{"high": 3, "medium": 2, "low": 1}
+	statusRanks = map[string]int{"open": 2, "": 1, "done": 0}
 )
 
-type iconSet struct {
-	Issue, Note, User, Namespace string
-	Blocks, Subtask, Related     string
-	Assignee, Created            string
-	Tag, Calendar                string
-	Check, Cross                 string
+const (
+	iconCalendar  = "\uf133"
+	iconCheck     = "\uf00c"
+	iconCross     = "\uf00d"
+	iconNamespace = "\uf07b"
+)
+
+func render(rm RenderMap, key string, short bool) string {
+	v, ok := rm[key]
+	if !ok {
+		v, ok = rm[""]
+		if !ok {
+			return ""
+		}
+	}
+	if short {
+		return v.c.Sprint(v.s)
+	}
+	return v.c.Sprint(v.l)
 }
 
-var icons = iconSet{
-	Issue:     "\uf188", // bug icon
-	Note:      "\uf15c", // file-text
-	User:      "\uf007", // user
-	Namespace: "\uf07b", // folder
-	Blocks:    "\uf068", // minus
-	Subtask:   "\uf0da", // caret-right
-	Related:   "\uf0c1", // link
-	Assignee:  "\uf007", // user
-	Created:   "\uf007", // user
-	Tag:       "\uf02b", // tag
-	Calendar:  "\uf133", // calendar
-	Check:     "\uf00c", // check
-	Cross:     "\uf00d", // times
-}
-
-func typeIcon(t string) string {
-	switch t {
-	case "issue":
-		return icons.Issue
-	case "note":
-		return icons.Note
-	case "user":
-		return icons.User
-	case "namespace":
-		return icons.Namespace
-	default:
-		return icons.Issue
-	}
-}
-
-func typeIconColored(t string) string {
-	switch t {
-	case "issue":
-		return typeIssue.Sprint(icons.Issue)
-	case "note":
-		return typeNote.Sprint(icons.Note)
-	case "user":
-		return typeUser.Sprint(icons.User)
-	case "namespace":
-		return typeNs.Sprint(icons.Namespace)
-	default:
-		return typeIssue.Sprint(icons.Issue)
-	}
-}
-
-func statusIcon(s string) string {
-	if s == "done" {
-		return icons.Check
-	}
-	return icons.Cross
-}
-
-func statusIconColored(s string) string {
-	if s == "" {
-		return " "
-	}
-	if s == "done" {
-		return dimColor.Sprint("○")
-	}
-	return dimColor.Sprint("●")
-}
-
-func statusColored(s string) string {
-	if s == "" {
-		return dimColor.Sprint("—")
-	}
-	if s == "done" {
-		return statusDone.Sprint("○ done")
-	}
-	return statusOpen.Sprint("● open")
-}
-
-func prioColored(p string) string {
-	switch p {
-	case "high":
-		return prioHigh.Sprint("● high")
-	case "medium":
-		return prioMedium.Sprint("◆ medium")
-	case "low":
-		return prioLow.Sprint("○ low")
-	default:
-		return dimColor.Sprint("—")
+func getDisplayTags(n *models.Node) []string {
+	var tags []string
+	for _, t := range n.Tags {
+		if !strings.HasPrefix(t, "_") {
+			tags = append(tags, t)
+		}
 	}
+	return tags
 }
 
 func PrintNodes(w io.Writer, nodes []*models.Node, jsonOut bool) error {
 	if jsonOut {
 		return json.NewEncoder(w).Encode(nodes)
 	}
-	fmt.Fprintln(w)
 	if len(nodes) == 0 {
-		fmt.Fprintln(w, dimColor.Sprint("  No results."))
+		fmt.Fprintln(w, cDim.Sprint("No results."))
 		return nil
 	}
 
+	fmt.Fprintln(w)
 	sort.Slice(nodes, func(i, j int) bool {
 		si, sj := nodes[i].GetProperty("status"), nodes[j].GetProperty("status")
 		if si != sj {
-			return statusRank(si) > statusRank(sj)
+			return statusRanks[si] > statusRanks[sj]
 		}
-		pi, pj := nodes[i].GetProperty("prio"), nodes[j].GetProperty("prio")
-		return prioRank(pi) > prioRank(pj)
+		return prioRanks[nodes[i].GetProperty("prio")] > prioRanks[nodes[j].GetProperty("prio")]
 	})
 
 	for _, n := range nodes {
 		tags := getDisplayTags(n)
-		nodeType := n.GetType()
-		var typeAndStatus string
-		if nodeType == "issue" {
-			typeAndStatus = statusIconColored(n.GetProperty("status"))
-		} else {
-			typeAndStatus = typeIconColored(nodeType) + " " + statusIconColored(n.GetProperty("status"))
-		}
-		fmt.Fprintf(w, "  %s %s %s %s %s",
-			idColor.Sprintf("%s", n.ID),
-			prioColoredShort(n.GetProperty("prio")),
-			typeAndStatus,
-			titleColor.Sprint(truncate(n.Title, 35)),
-			dimColor.Sprint("["+n.GetProperty("namespace")+"]"),
+		fmt.Fprintf(w, "  %s %s %s %s %s %s",
+			cDim.Sprint(n.ID),
+			render(prioRM, n.GetProperty("prio"), true),
+			render(statusRM, n.GetProperty("status"), true),
+			render(typeRM, n.GetProperty("type"), true),
+			cTitle.Sprint(truncate(n.Title, 35)),
+			cDim.Sprint("["+n.GetProperty("namespace")+"]"),
 		)
 		if len(tags) > 0 {
-			var hashTags []string
-			for _, t := range tags {
-				hashTags = append(hashTags, "#"+t)
-			}
-			fmt.Fprintf(w, " %s", tagColor.Sprint(strings.Join(hashTags, " ")))
+			fmt.Fprintf(w, " %s", cPrimary.Sprint("#"+strings.Join(tags, " #")))
 		}
 		fmt.Fprintln(w)
 	}
@@ -173,121 +119,53 @@ func PrintNodes(w io.Writer, nodes []*models.Node, jsonOut bool) error {
 	return nil
 }
 
-func prioColoredShort(p string) string {
-	switch p {
-	case "high":
-		return prioHigh.Sprint("\uf0e7 ")
-	case "medium":
-		return prioMedium.Sprint("\uf12a ")
-	case "low":
-		return prioLow.Sprint("\uf068 ")
-	default:
-		return "  "
-	}
-}
-
-func prioRank(p string) int {
-	switch p {
-	case "high":
-		return 3
-	case "medium":
-		return 2
-	case "low":
-		return 1
-	default:
-		return 0
-	}
-}
-
-func statusRank(s string) int {
-	switch s {
-	case "open":
-		return 2
-	case "done":
-		return 0
-	default:
-		return 1
-	}
-}
-
-func getDisplayTags(n *models.Node) []string {
-	var tags []string
-	for _, t := range n.Tags {
-		if _, _, ok := models.ParseTag(t); !ok {
-			tags = append(tags, t)
-		}
-	}
-	return tags
-}
-
 func PrintNode(w io.Writer, n *models.Node, jsonOut bool) error {
 	if jsonOut {
 		return json.NewEncoder(w).Encode(n)
 	}
-	icon := typeIcon(n.GetType())
-	nodeType := strings.Title(n.GetType())
-
 	fmt.Fprintln(w)
-	fmt.Fprintf(w, "  %s %s %s %s\n",
-		icon,
-		idColor.Sprint(n.ID),
-		titleColor.Sprint(n.Title),
-		dimColor.Sprint("["+nodeType+"]"),
-	)
-	fmt.Fprintln(w, dimColor.Sprint("  ───────────────────────────"))
-	fmt.Fprintf(w, "  Status:    %s\n", statusColored(n.GetProperty("status")))
-	fmt.Fprintf(w, "  Priority:  %s\n", prioColored(n.GetProperty("prio")))
-	fmt.Fprintf(w, "  Namespace: %s\n", nsColor.Sprint(n.GetProperty("namespace")))
+	fmt.Fprintf(w, "  %s %s %s\n", render(typeRM, n.GetProperty("type"), false), cDim.Sprint(n.ID), cTitle.Sprint(n.Title))
+	fmt.Fprintln(w, cDim.Sprint("  ───────────────────────────────"))
+	fmt.Fprintf(w, "  Status:    %s\n", render(statusRM, n.GetProperty("status"), false))
+	fmt.Fprintf(w, "  Priority:  %s\n", render(prioRM, n.GetProperty("prio"), false))
+	fmt.Fprintf(w, "  Namespace: %s\n", cWarn.Sprint(n.GetProperty("namespace")))
 	if n.DueDate != "" {
-		fmt.Fprintf(w, "  Due:       %s %s\n", icons.Calendar, n.DueDate)
+		fmt.Fprintf(w, "  Due:       %s %s\n", iconCalendar, n.DueDate)
 	}
-	fmt.Fprintf(w, "  Created:   %s\n", dimColor.Sprint(n.CreatedAt))
+	fmt.Fprintf(w, "  Created:   %s\n", cDim.Sprint(n.CreatedAt))
+	fmt.Fprintf(w, "  Updated:   %s\n", cDim.Sprint(n.UpdatedAt))
 
 	if n.Content != "" {
-		fmt.Fprintln(w)
-		fmt.Fprintln(w, labelColor.Sprint("  Content:"))
-		for _, line := range strings.Split(n.Content, "\n") {
-			fmt.Fprintf(w, dimColor.Sprint("  │ ")+contentColor.Sprint("%s\n"), line)
+		fmt.Fprintln(w, "\n"+cPrimary.Sprint("  Content:"))
+		for i, line := range strings.Split(n.Content, "\n") {
+			if i > 5 {
+				fmt.Fprintf(w, "%s ...\n", cDim.Sprint("  │ "))
+				break
+			}
+			fmt.Fprintf(w, "%s%s\n", cDim.Sprint("  │ "), cText.Sprint(line))
 		}
 	}
 
-	if len(n.Tags) > 0 {
-		var tags []string
-		for _, t := range n.Tags {
-			if _, _, ok := models.ParseTag(t); !ok {
-				tags = append(tags, t)
-			}
-		}
-		if len(tags) > 0 {
-			fmt.Fprintln(w)
-			fmt.Fprintf(w, "  Tags: %s\n", tagColor.Sprint(strings.Join(tags, " • ")))
-		}
+	if tags := getDisplayTags(n); len(tags) > 0 {
+		fmt.Fprintf(w, "\n  tags: %s\n\n", cPrimary.Sprint(strings.Join(tags, " • ")))
 	}
 
-	if len(n.Relations) > 0 {
-		fmt.Fprintln(w)
-		fmt.Fprintln(w, labelColor.Sprint("  Relations:"))
-		for relType, ids := range n.Relations {
-			if relType == "created" {
-				continue
+	if db, err := db.GetDB(); err == nil {
+		if len(n.Relations) > 0 {
+			for relType, ids := range n.Relations {
+				fmt.Fprintf(w, "  %s\n", string(relType))
+				if relIcon, ok := relIcons[string(relType)]; ok && relType != "created" {
+					for _, id := range ids {
+						node, err := db.NodeByID(id)
+						if err == nil {
+							fmt.Fprintf(w, "    %s %s\n", relIcon, node.Title)
+						}
+					}
+				}
 			}
-			relIcon := ""
-			switch relType {
-			case "blocks":
-				relIcon = icons.Blocks
-			case "subtask":
-				relIcon = icons.Subtask
-			case "related":
-				relIcon = icons.Related
-			case "assignee":
-				relIcon = icons.Assignee
-			}
-			coloredIDs := make([]string, len(ids))
-			for i, id := range ids {
-				coloredIDs[i] = idColor.Sprint(id)
-			}
-			fmt.Fprintf(w, "    %s %s  %s\n", relIcon, strings.Title(string(relType)), strings.Join(coloredIDs, " "))
 		}
+	} else {
+		fmt.Fprintf(w, "failed to attach to db: %v", err)
 	}
 
 	fmt.Fprintln(w)
@@ -299,30 +177,27 @@ func PrintAliases(w io.Writer, aliases []*db.Alias, jsonOut bool) error {
 		return json.NewEncoder(w).Encode(aliases)
 	}
 	if len(aliases) == 0 {
-		fmt.Fprintln(w, dimColor.Sprint("  No aliases defined."))
+		fmt.Fprintln(w, cDim.Sprint("No aliases defined."))
 		return nil
 	}
 	fmt.Fprintln(w)
 	for _, a := range aliases {
-		fmt.Fprintf(w, "  %s  %s\n",
-			idColor.Sprint(a.Name),
-			dimColor.Sprint(a.Command),
-		)
+		fmt.Fprintf(w, "  %s  %s\n", cPrimary.Sprint(a.Name), cDim.Sprint(a.Command))
 	}
 	fmt.Fprintln(w)
 	return nil
 }
 
-func PrintSuccess(w io.Writer, format string, args ...interface{}) {
-	fmt.Fprintf(w, icons.Check+" "+format+"\n", args...)
-}
-
-func PrintDeleted(w io.Writer, id string) {
-	fmt.Fprintf(w, "  "+icons.Cross+" Deleted %s\n", idColor.Sprint(id))
-}
-
-func PrintCreated(w io.Writer, dbPath string) {
-	fmt.Fprintf(w, "  "+icons.Namespace+" Created %s\n", dimColor.Sprint(dbPath))
+func PrintAction(w io.Writer, action, detail string, isError bool) {
+	if isError {
+		fmt.Fprintln(w, cBad.Sprint(iconCross+" "+action+" ")+cDim.Sprint(detail))
+		return
+	}
+	icon := iconCheck
+	if action == "Created" {
+		icon = iconNamespace
+	}
+	fmt.Fprintln(w, cGood.Sprint(icon+" "+action+" ")+cDim.Sprint(detail))
 }
 
 func truncate(s string, max int) string {

parse/mentions.go

@@ -6,11 +6,11 @@ import (
 	"slices"
 )
 
-var mentionRegex = regexp.MustCompile(`@([a-z0-9_]+)`)
+var r = regexp.MustCompile(`@([a-z0-9_]+)`)
 
-func Mentions(text string) []string {
+func Mentions(t string) []string {
 	seen := make(map[string]bool)
-	for _, m := range mentionRegex.FindAllStringSubmatch(text, -1) {
+	for _, m := range r.FindAllStringSubmatch(t, -1) {
 		seen[m[1]] = true
 	}
 	return slices.Collect(maps.Keys(seen))