fix(resolve): fall back to channel when bare name fails user resolution

Bare names like "stand-up" were always assumed to be users by
LooksLikeUser(), causing "user not found" when the name was actually
a channel. Add ResolveTarget() that tries user (DM) first for bare
names, then falls back to channel resolution before erroring.

Explicit prefixes (#channel, @user) remain unambiguous with no fallback.

Author: isaacrowntree

internal/api/resolve.go

@@ -164,6 +164,52 @@ func LooksLikeUser(target string) bool {
 	return true
 }
 
+// ResolveTarget resolves a bare name to a channel ID, trying the most likely
+// path first based on the name's syntax, then falling back to the other.
+//
+// Explicit prefixes are unambiguous:
+//
+//	#general → channel only (no fallback)
+//	@alice   → DM only     (no fallback)
+//
+// Bare names (e.g. "stand-up", "herman") are ambiguous — the name could be
+// either a channel or a user. We try the heuristic-preferred path first
+// (user for bare names) and fall back to the other on failure.
+//
+// Returns the resolved channel ID and whether the target resolved as a DM.
+func (r *Resolver) ResolveTarget(target string) (channelID string, isDM bool, err error) {
+	// Explicit #channel — no ambiguity
+	if strings.HasPrefix(target, "#") {
+		id, err := r.ResolveChannel(target)
+		return id, false, err
+	}
+
+	// Explicit @user or user ID — no ambiguity
+	if strings.HasPrefix(target, "@") || isUserID(target) {
+		id, err := r.ResolveDM(target)
+		return id, true, err
+	}
+
+	// Explicit channel ID — no ambiguity
+	if isChannelID(target) {
+		return target, false, nil
+	}
+
+	// Bare name — ambiguous. Try user (DM) first, fall back to channel.
+	id, dmErr := r.ResolveDM(target)
+	if dmErr == nil {
+		return id, true, nil
+	}
+
+	id, chErr := r.ResolveChannel(target)
+	if chErr == nil {
+		return id, false, nil
+	}
+
+	// Both failed — return a combined error
+	return "", false, fmt.Errorf("could not resolve %q as a user or channel", target)
+}
+
 func (r *Resolver) loadUsers() error {
 	r.mu.Lock()
 	if r.usersLoaded {

pkg/cmd/file/upload.go

@@ -102,14 +102,10 @@ func uploadRun(opts *uploadOptions) error {
 		}
 	}
 
-	// Resolve channel/DM
+	// Resolve channel/DM — ResolveTarget handles bare names by trying
+	// user (DM) first, then falling back to channel.
 	resolver := api.NewResolver(client.Slack)
-	var channelID string
-	if api.LooksLikeUser(opts.channel) {
-		channelID, err = resolver.ResolveDM(opts.channel)
-	} else {
-		channelID, err = resolver.ResolveChannel(opts.channel)
-	}
+	channelID, _, err := resolver.ResolveTarget(opts.channel)
 
 	// If resolution fails with missing scope, try the other token
 	if err != nil && api.IsMissingScopeError(err) {
@@ -120,11 +116,7 @@ func uploadRun(opts *uploadOptions) error {
 		if altErr == nil {
 			fmt.Fprintf(ios.ErrOut, "%s Retrying with alternate token\n", cs.Yellow("!"))
 			altResolver := api.NewResolver(altClient.Slack)
-			if api.LooksLikeUser(opts.channel) {
-				channelID, err = altResolver.ResolveDM(opts.channel)
-			} else {
-				channelID, err = altResolver.ResolveChannel(opts.channel)
-			}
+			channelID, _, err = altResolver.ResolveTarget(opts.channel)
 			if err == nil {
 				client = altClient
 			}

pkg/cmd/message/send.go

@@ -108,13 +108,9 @@ func sendRun(opts *sendOptions) error {
 
 	resolver := api.NewResolver(client.Slack)
 
-	// Resolve target to a channel ID — auto-detect DMs vs channels
-	var channelID string
-	if api.LooksLikeUser(opts.channel) {
-		channelID, err = resolver.ResolveDM(opts.channel)
-	} else {
-		channelID, err = resolver.ResolveChannel(opts.channel)
-	}
+	// Resolve target to a channel ID — auto-detect DMs vs channels.
+	// ResolveTarget handles bare names by trying user (DM) first, then channel.
+	channelID, _, err := resolver.ResolveTarget(opts.channel)
 
 	// Bot-fallback: if resolution failed with missing_scope on the user token,
 	// retry with the bot client (which typically has channels:read).
@@ -123,11 +119,7 @@ func sendRun(opts *sendOptions) error {
 		if botErr == nil {
 			fmt.Fprintf(ios.ErrOut, "%s User token missing scope for channel lookup — falling back to bot token\n", cs.Yellow("!"))
 			botResolver := api.NewResolver(botClient.Slack)
-			if api.LooksLikeUser(opts.channel) {
-				channelID, err = botResolver.ResolveDM(opts.channel)
-			} else {
-				channelID, err = botResolver.ResolveChannel(opts.channel)
-			}
+			channelID, _, err = botResolver.ResolveTarget(opts.channel)
 		}
 	}