feat(bit): add BYTE/BIT option support for BITPOS command (Redis 7.0+)

Add explicit BYTE/BIT index option to BITPOS with strict syntax
validation matching Redis 7.0 behavior. Reject invalid option values
and extra arguments. Add Go integration tests for BYTE option, BIT vs
BYTE comparison, case-insensitivity and error cases.

Ultraworked with [Sisyphus](https://github.com/code-yeongyu/oh-my-openagent)

Co-authored-by: Sisyphus <clio-agent@sisyphuslabs.ai>

Author: gongna-au

src/commands/cmd_bit.cc

@@ -156,39 +156,31 @@ class CommandBitPos : public Commander {
   using Commander::Parse;
 
   Status Parse(const std::vector<std::string> &args) override {
-    if (args.size() >= 4) {
-      auto parse_start = ParseInt<int64_t>(args[3], 10);
-      if (!parse_start) {
-        return {Status::RedisParseErr, errValueNotInteger};
-      }
+    auto parse_bit = ParseInt<int>(args[2], 10);
+    if (!parse_bit || (*parse_bit != 0 && *parse_bit != 1)) {
+      return {Status::RedisParseErr, "The bit argument must be 1 or 0."};
+    }
+    bit_ = (*parse_bit == 1);
 
-      start_ = *parse_start;
+    if (args.size() >= 4) {
+      start_ = GET_OR_RET(ParseInt<int64_t>(args[3], 10));
     }
 
     if (args.size() >= 5) {
-      auto parse_stop = ParseInt<int64_t>(args[4], 10);
-      if (!parse_stop) {
-        return {Status::RedisParseErr, errValueNotInteger};
-      }
-
+      stop_ = GET_OR_RET(ParseInt<int64_t>(args[4], 10));
       stop_given_ = true;
-      stop_ = *parse_stop;
     }
 
-    if (args.size() >= 6 && util::EqualICase(args[5], "BIT")) {
-      is_bit_index_ = true;
-    }
-
-    auto parse_arg = ParseInt<int64_t>(args[2], 10);
-    if (!parse_arg) {
-      return {Status::RedisParseErr, errValueNotInteger};
-    }
-    if (*parse_arg == 0) {
-      bit_ = false;
-    } else if (*parse_arg == 1) {
-      bit_ = true;
-    } else {
-      return {Status::RedisParseErr, "The bit argument must be 1 or 0."};
+    if (args.size() == 6) {
+      if (util::EqualICase(args[5], "BIT")) {
+        is_bit_index_ = true;
+      } else if (util::EqualICase(args[5], "BYTE")) {
+        is_bit_index_ = false;
+      } else {
+        return {Status::RedisParseErr, errInvalidSyntax};
+      }
+    } else if (args.size() > 6) {
+      return {Status::RedisParseErr, errInvalidSyntax};
     }
 
     return Commander::Parse(args);

tests/gocase/unit/type/bitmap/bitmap_test.go

@@ -400,6 +400,52 @@ func TestBitmap(t *testing.T) {
 		require.EqualValues(t, 2, cmd.Val())
 	})
 
+	t.Run("BITPOS BYTE option produces same result as default byte-indexed mode", func(t *testing.T) {
+		require.NoError(t, rdb.Set(ctx, "mykey", "\x00\xff\xf0", 0).Err())
+		byteResult := rdb.BitPos(ctx, "mykey", 1, 1)
+		require.NoError(t, byteResult.Err())
+		explicitByte := rdb.BitPosSpan(ctx, "mykey", 1, 1, -1, "byte")
+		require.NoError(t, explicitByte.Err())
+		require.EqualValues(t, byteResult.Val(), explicitByte.Val())
+	})
+
+	t.Run("BITPOS BYTE option is case-insensitive", func(t *testing.T) {
+		require.NoError(t, rdb.Set(ctx, "mykey", "\x00\xff\xf0", 0).Err())
+		lower, err := rdb.Do(ctx, "BITPOS", "mykey", 1, 0, -1, "byte").Int64()
+		require.NoError(t, err)
+		upper, err := rdb.Do(ctx, "BITPOS", "mykey", 1, 0, -1, "BYTE").Int64()
+		require.NoError(t, err)
+		require.EqualValues(t, lower, upper)
+	})
+
+	t.Run("BITPOS BIT vs BYTE gives different results for same range", func(t *testing.T) {
+		require.NoError(t, rdb.Set(ctx, "mykey", "\x00\xff\xf0", 0).Err())
+		bitResult := rdb.BitPosSpan(ctx, "mykey", 1, 0, 15, "bit")
+		require.NoError(t, bitResult.Err())
+		require.EqualValues(t, 8, bitResult.Val())
+		byteResult := rdb.BitPosSpan(ctx, "mykey", 1, 0, 15, "byte")
+		require.NoError(t, byteResult.Err())
+		require.EqualValues(t, 8, byteResult.Val())
+		bitResult2 := rdb.BitPosSpan(ctx, "mykey", 1, 0, 7, "bit")
+		require.NoError(t, bitResult2.Err())
+		require.EqualValues(t, -1, bitResult2.Val())
+		byteResult2 := rdb.BitPosSpan(ctx, "mykey", 1, 0, 7, "byte")
+		require.NoError(t, byteResult2.Err())
+		require.EqualValues(t, 8, byteResult2.Val())
+	})
+
+	t.Run("BITPOS rejects invalid option", func(t *testing.T) {
+		require.NoError(t, rdb.Set(ctx, "mykey", "\xff", 0).Err())
+		err := rdb.Do(ctx, "BITPOS", "mykey", 1, 0, -1, "INVALID").Err()
+		require.Error(t, err)
+	})
+
+	t.Run("BITPOS rejects extra arguments after BYTE/BIT", func(t *testing.T) {
+		require.NoError(t, rdb.Set(ctx, "mykey", "\xff", 0).Err())
+		err := rdb.Do(ctx, "BITPOS", "mykey", 1, 0, -1, "BIT", "extra").Err()
+		require.Error(t, err)
+	})
+
 	/* Test cases adapted from redis test cases : https://github.com/redis/redis/blob/unstable/tests/unit/bitops.tcl
 	 */
 	t.Run("BITPOS bit=0 with empty key returns 0", func(t *testing.T) {