feat: add collections and multi-source query filtering

Named collections grouping multiple sources with a default "All"
collection. SourceIDs filtering in both DuckDB and SQLite query paths.
CLI collections command with CRUD operations. Includes fixes for buffer
corruption in normalizeRawMIME, deep-copy in Clone(), and openStore
consolidation.

Author: jesserobbins

cmd/msgvault/cmd/account_scope.go

@@ -1,6 +1,7 @@
 package cmd
 
 import (
+	"errors"
 	"fmt"
 
 	"github.com/wesm/msgvault/internal/store"
@@ -9,35 +10,45 @@ import (
 // AccountScope is the result of resolving a user-supplied --account
 // flag against the store.
 type AccountScope struct {
-	Input  string
-	Source *store.Source
+	Input      string
+	Source     *store.Source
+	Collection *store.CollectionWithSources
 }
 
 // IsEmpty reports whether the scope resolved to nothing.
 func (s AccountScope) IsEmpty() bool {
-	return s.Source == nil
+	return s.Source == nil && s.Collection == nil
+}
+
+// IsCollection reports whether the scope refers to a collection.
+func (s AccountScope) IsCollection() bool {
+	return s.Collection != nil
 }
 
 // SourceIDs returns the source IDs that this scope expands to.
 func (s AccountScope) SourceIDs() []int64 {
-	if s.Source != nil {
+	switch {
+	case s.Collection != nil:
+		return append([]int64(nil), s.Collection.SourceIDs...)
+	case s.Source != nil:
 		return []int64{s.Source.ID}
 	}
 	return nil
 }
 
 // DisplayName returns a human-readable label for the scope.
 func (s AccountScope) DisplayName() string {
-	if s.Source != nil {
+	switch {
+	case s.Collection != nil:
+		return s.Collection.Name
+	case s.Source != nil:
 		return s.Source.Identifier
 	}
 	return ""
 }
 
 // ResolveAccount resolves a user-supplied --account string against
-// the store. Returns an empty scope if input is empty. Currently
-// looks up sources by identifier or display name; collection lookup
-// will be added when collections are implemented.
+// the store. Collections are checked first, then sources.
 func ResolveAccount(
 	st *store.Store, input string,
 ) (AccountScope, error) {
@@ -46,6 +57,21 @@ func ResolveAccount(
 		return scope, nil
 	}
 
+	// Try collection first.
+	coll, err := st.GetCollectionByName(input)
+	switch {
+	case err == nil:
+		scope.Collection = coll
+		return scope, nil
+	case errors.Is(err, store.ErrCollectionNotFound):
+		// Fall through to source lookup.
+	default:
+		return scope, fmt.Errorf(
+			"look up collection %q: %w", input, err,
+		)
+	}
+
+	// Source lookup.
 	sources, err := st.GetSourcesByIdentifierOrDisplayName(input)
 	if err != nil {
 		return scope, fmt.Errorf(
@@ -54,8 +80,9 @@ func ResolveAccount(
 	}
 	if len(sources) == 0 {
 		return scope, fmt.Errorf(
-			"no account or source found for %q "+
-				"(try 'msgvault list-accounts')",
+			"no collection or source found for %q "+
+				"(try 'msgvault collections list' or "+
+				"'msgvault list-accounts')",
 			input,
 		)
 	}

cmd/msgvault/cmd/collections.go

@@ -0,0 +1,239 @@
+package cmd
+
+import (
+	"fmt"
+	"os"
+	"strconv"
+	"strings"
+	"text/tabwriter"
+
+	"github.com/spf13/cobra"
+	"github.com/wesm/msgvault/internal/store"
+)
+
+var collectionsCmd = &cobra.Command{
+	Use:   "collections",
+	Short: "Manage named groups of accounts",
+	Long: `Collections are named groupings of accounts that let you view and
+deduplicate across multiple sources as one unified archive.
+
+A default "All" collection is created automatically and includes
+every account.`,
+}
+
+var collectionsCreateCmd = &cobra.Command{
+	Use:   "create <name> --accounts <email1,email2,...>",
+	Short: "Create a new collection",
+	Args:  cobra.ExactArgs(1),
+	RunE:  runCollectionsCreate,
+}
+
+var collectionsListCmd = &cobra.Command{
+	Use:   "list",
+	Short: "List all collections",
+	RunE:  runCollectionsList,
+}
+
+var collectionsShowCmd = &cobra.Command{
+	Use:   "show <name>",
+	Short: "Show collection details",
+	Args:  cobra.ExactArgs(1),
+	RunE:  runCollectionsShow,
+}
+
+var collectionsAddCmd = &cobra.Command{
+	Use:   "add <name> --accounts <email1,email2,...>",
+	Short: "Add accounts to a collection",
+	Args:  cobra.ExactArgs(1),
+	RunE:  runCollectionsAdd,
+}
+
+var collectionsRemoveCmd = &cobra.Command{
+	Use:   "remove <name> --accounts <email1,email2,...>",
+	Short: "Remove accounts from a collection",
+	Args:  cobra.ExactArgs(1),
+	RunE:  runCollectionsRemove,
+}
+
+var collectionsDeleteCmd = &cobra.Command{
+	Use:   "delete <name>",
+	Short: "Delete a collection (sources and messages are untouched)",
+	Args:  cobra.ExactArgs(1),
+	RunE:  runCollectionsDelete,
+}
+
+var collectionsAccounts string
+
+func runCollectionsCreate(_ *cobra.Command, args []string) error {
+	st, err := openStoreAndInit()
+	if err != nil {
+		return err
+	}
+	defer func() { _ = st.Close() }()
+
+	name := args[0]
+	sourceIDs, err := resolveAccountList(st, collectionsAccounts)
+	if err != nil {
+		return err
+	}
+
+	coll, err := st.CreateCollection(name, "", sourceIDs)
+	if err != nil {
+		return err
+	}
+	fmt.Printf("Created collection %q with %d source(s).\n",
+		coll.Name, len(sourceIDs))
+	return nil
+}
+
+func runCollectionsList(_ *cobra.Command, _ []string) error {
+	st, err := openStoreAndInit()
+	if err != nil {
+		return err
+	}
+	defer func() { _ = st.Close() }()
+
+	collections, err := st.ListCollections()
+	if err != nil {
+		return err
+	}
+	if len(collections) == 0 {
+		fmt.Println("No collections.")
+		return nil
+	}
+
+	w := tabwriter.NewWriter(os.Stdout, 0, 0, 2, ' ', 0)
+	_, _ = fmt.Fprintln(w, "NAME\tSOURCES\tMESSAGES")
+	for _, c := range collections {
+		_, _ = fmt.Fprintf(w, "%s\t%d\t%s\n",
+			c.Name, len(c.SourceIDs),
+			formatCount(c.MessageCount))
+	}
+	_ = w.Flush()
+	return nil
+}
+
+func runCollectionsShow(_ *cobra.Command, args []string) error {
+	st, err := openStoreAndInit()
+	if err != nil {
+		return err
+	}
+	defer func() { _ = st.Close() }()
+
+	coll, err := st.GetCollectionByName(args[0])
+	if err != nil {
+		return err
+	}
+
+	fmt.Printf("Collection: %s\n", coll.Name)
+	if coll.Description != "" {
+		fmt.Printf("Description: %s\n", coll.Description)
+	}
+	fmt.Printf("Sources: %d\n", len(coll.SourceIDs))
+	fmt.Printf("Messages: %s\n", formatCount(coll.MessageCount))
+	fmt.Printf("Created: %s\n", coll.CreatedAt.Format("2006-01-02 15:04"))
+
+	if len(coll.SourceIDs) > 0 {
+		fmt.Println("\nMember source IDs:", coll.SourceIDs)
+	}
+	return nil
+}
+
+func runCollectionsAdd(_ *cobra.Command, args []string) error {
+	st, err := openStoreAndInit()
+	if err != nil {
+		return err
+	}
+	defer func() { _ = st.Close() }()
+
+	sourceIDs, err := resolveAccountList(st, collectionsAccounts)
+	if err != nil {
+		return err
+	}
+
+	if err := st.AddSourcesToCollection(args[0], sourceIDs); err != nil {
+		return err
+	}
+	fmt.Printf("Added %d source(s) to %q.\n", len(sourceIDs), args[0])
+	return nil
+}
+
+func runCollectionsRemove(_ *cobra.Command, args []string) error {
+	st, err := openStoreAndInit()
+	if err != nil {
+		return err
+	}
+	defer func() { _ = st.Close() }()
+
+	sourceIDs, err := resolveAccountList(st, collectionsAccounts)
+	if err != nil {
+		return err
+	}
+
+	if err := st.RemoveSourcesFromCollection(args[0], sourceIDs); err != nil {
+		return err
+	}
+	fmt.Printf("Removed %d source(s) from %q.\n", len(sourceIDs), args[0])
+	return nil
+}
+
+func runCollectionsDelete(_ *cobra.Command, args []string) error {
+	st, err := openStoreAndInit()
+	if err != nil {
+		return err
+	}
+	defer func() { _ = st.Close() }()
+
+	if err := st.DeleteCollection(args[0]); err != nil {
+		return err
+	}
+	fmt.Printf("Deleted collection %q.\n", args[0])
+	return nil
+}
+
+
+func resolveAccountList(st *store.Store, accounts string) ([]int64, error) {
+	if accounts == "" {
+		return nil, fmt.Errorf("--accounts is required")
+	}
+	parts := strings.Split(accounts, ",")
+	var ids []int64
+	for _, p := range parts {
+		p = strings.TrimSpace(p)
+		if p == "" {
+			continue
+		}
+		// Try as numeric ID first
+		if id, err := strconv.ParseInt(p, 10, 64); err == nil {
+			ids = append(ids, id)
+			continue
+		}
+		// Resolve by identifier
+		scope, err := ResolveAccount(st, p)
+		if err != nil {
+			return nil, err
+		}
+		ids = append(ids, scope.SourceIDs()...)
+	}
+	if len(ids) == 0 {
+		return nil, fmt.Errorf("no valid accounts in --accounts")
+	}
+	return ids, nil
+}
+
+func init() {
+	rootCmd.AddCommand(collectionsCmd)
+	collectionsCmd.AddCommand(collectionsCreateCmd)
+	collectionsCmd.AddCommand(collectionsListCmd)
+	collectionsCmd.AddCommand(collectionsShowCmd)
+	collectionsCmd.AddCommand(collectionsAddCmd)
+	collectionsCmd.AddCommand(collectionsRemoveCmd)
+	collectionsCmd.AddCommand(collectionsDeleteCmd)
+
+	collectionsCreateCmd.Flags().StringVar(&collectionsAccounts,
+		"accounts", "", "Comma-separated account emails or source IDs")
+	collectionsAddCmd.Flags().StringVar(&collectionsAccounts,
+		"accounts", "", "Comma-separated account emails or source IDs")
+	collectionsRemoveCmd.Flags().StringVar(&collectionsAccounts,
+		"accounts", "", "Comma-separated account emails or source IDs")
+}

cmd/msgvault/cmd/deduplicate.go

@@ -49,23 +49,13 @@ var (
 )
 
 func runDeduplicate(cmd *cobra.Command, _ []string) error {
-	dbPath := cfg.DatabaseDSN()
-	if _, err := os.Stat(dbPath); os.IsNotExist(err) {
-		return fmt.Errorf(
-			"database not found: %s\nRun 'msgvault init-db' first",
-			dbPath,
-		)
-	}
-
-	st, err := store.Open(dbPath)
+	st, err := openStoreAndInit()
 	if err != nil {
-		return fmt.Errorf("open database: %w", err)
+		return err
 	}
 	defer func() { _ = st.Close() }()
 
-	if err := st.InitSchema(); err != nil {
-		return fmt.Errorf("init schema: %w", err)
-	}
+	dbPath := cfg.DatabaseDSN()
 
 	deletionsDir := filepath.Join(cfg.Data.DataDir, "deletions")
 
@@ -132,7 +122,7 @@ func runDeduplicate(cmd *cobra.Command, _ []string) error {
 		return runDeduplicatePerSource(cmd, st, config)
 	}
 
-	return runDeduplicateOnce(cmd, st, dbPath, config, engine)
+	return runDeduplicateOnce(cmd, dbPath, config, engine)
 }
 
 func runDeduplicatePerSource(
@@ -219,7 +209,6 @@ func runDeduplicatePerSource(
 
 func runDeduplicateOnce(
 	cmd *cobra.Command,
-	_ *store.Store,
 	dbPath string,
 	cfgScoped dedup.Config,
 	engine *dedup.Engine,

cmd/msgvault/cmd/import_imessage.go

@@ -120,6 +120,12 @@ func runImportImessage(cmd *cobra.Command, _ []string) error {
 
 func openStoreAndInit() (*store.Store, error) {
 	dbPath := cfg.DatabaseDSN()
+	if _, err := os.Stat(dbPath); os.IsNotExist(err) {
+		return nil, fmt.Errorf(
+			"database not found: %s\nRun 'msgvault init-db' first",
+			dbPath,
+		)
+	}
 	s, err := store.Open(dbPath)
 	if err != nil {
 		return nil, fmt.Errorf("open database: %w", err)