Jelly,  9  7 bytes

-2 thanks to caird coinheringaahing (‘Ḋ$ -> ‘€ and use of the newer alias for Ðf, Ƈ.)

b‘€EƇZL 

A monadic link accepting and returning numbers

Try it online! or see a test suite (inputs one to 32 inclusive).

How?

b‘€EƇZL - Link: number, n € - for each (i in [1..n]): ‘ - increment = i+1 - -> [2,3,4,...,n+1] b - convert (n) to those bases Ƈ - filter keep if: E - all elements are equal Z - transpose L - length (note: length of the transpose of a list of lists is the length of the - longest item in the original list, but shorter than L€Ṁ) 

Or maybe I should have done:

b‘€EƇZLo1 

...just for the Lo1z.

JavaScript (ES6), 62 bytes

f=(n,b=2,l=0,d=n)=>d?n%b<1|n%b-d%b?f(n,b+1):f(n,b,l+1,d/b|0):l

<input oninput=o.textContent=f(this.value)><pre id=o>

Haskell, 86 81 79 bytes

2 bytes saved thanks to Laikoni

0!y=[] x!y=mod x y:div x y!y length.head.filter(all=<<(==).head).(<$>[2..]).(!) 

Try it online!

Since this has died down a bit, here's my approach. It's a golfed version of the sample code I made for the question. I think it can definitely be shorter. I just thought I'd put it out there.

Husk, 13 11 bytes

-2 bytes thanks to zgarb

L←fȯ¬tuMBtN 

Try it online!

05AB1E, 8 bytes

L>вʒË}нg 

Try it online!

-1 thanks to kalsowerus.

Mathematica, 71 bytes

Max[L/@Select[Array[a~IntegerDigits~#&,a=#,2],(L=Length)@Union@#==1&]]& 

Try it online!

Brachylog, 12 bytes

+₁⟦₁b∋;?ḃ₍=l 

Try it online!

Python 3, 92 87 bytes

5 bytes thanks to Halvard Hummel.

g=lambda n,b,s=1:s*(n<b)or(n%b**2%-~b<1)*g(n//b,b,s+1) f=lambda n,b=2:g(n,b)or f(n,b+1) 

Try it online!

Husk, 7 bytes

LḟEMBtN 

Try it online!

Explanation

LḟEMBtN tN on numbers 2,3,4... MB map input to digits in base 2,3,4... ḟE find first list that only has one unique element L length of that 

APL (Dyalog Unicode), 28 26 bytes

Saved 2 bytes thanks to Adám!

{⌈/≢¨⍵/⍨1=≢∘∪¨⍵}⊢⊥⍣¯1⍨¨1+⍳ 

Try it online!

Pretty straightforward implementation.

{⌈/≢¨⍵/⍨(1=≢∘∪)¨⍵}⊢⊥⍣¯1⍨¨1+⍳ 1+⍳ ⍝ Make a range [2, n + 1] ¨ ⍝ For each b in that range ⊢⊥⍣¯1⍨ ⍝ Interpret n in base b (gives a vector of integers) ⍵/⍨ ⍝ Keep the representations where 1=≢∘∪¨⍵ ⍝ it's a repdigit ¨⍵ ⍝ For every representation, ≢∘∪ ⍝ is the length of it, without duplicates 1= ⍝ equal to 1? ≢¨ ⍝ Get the length of each of the remaining representations ⌈/ ⍝ Get the biggest length 

Mathematica, 58 bytes

FirstCase[#~IntegerDigits~Range[#+1],l:{a_ ..}:>Tr[1^l]]& 

Throws an error (because base-1 is not a valid base), but it is safe to ignore.

Of course, it is okay to take the length of the first repdigit (FirstCase), since numbers in lower bases cannot be shorter than in higher bases.

CJam (17 bytes)

{_,2>3+fb{)-!}=,} 

Online test suite. This is an anonymous block (function) which takes an integer on the stack and leaves an integer on the stack.

Works with brute force, using 3 as a fallback base to handle the special cases (input 1 or 2).

Perl 6, 49 bytes

{+first {[==] $_},map {[.polymod($^b xx*)]},2..*} 

Try it online!

Explanation

{ } # A lambda. map { },2..* # For each base from 2 to infinity... .polymod($^b xx*) # represent the input in that base, [ ] # and store it as an array. first {[==] $_}, # Get the first array whose elements # are all the same number. + # Return the length of that array. 

The polymod method is a generalization of Python's divmod: It performs repeated integer division using a given list of divisors, and returns the intermediate remainders.
It can be used to decompose a quantity into multiple units:

my ($sec, $min, $hrs, $days, $weeks) = $seconds.polymod(60, 60, 24, 7); 

When passing a lazy sequence as the list of divisors, polymod stops when the quotient reaches zero. Thus, giving it an infinite repetition of the same number, decomposes the input into digits of that base:

my @digits-in-base-37 = $number.polymod(37 xx *); 

I use this here because it allows arbitrarily high bases, in contrast to the string-based .base method which only supports up to base 36.

TI-BASIC, 37 bytes

Input N For(B,2,2N int(log(NB)/log(B If fPart(N(B-1)/(B^Ans-1 End 

Prompts for N, returns output in Ans.

Explanation

As an overview, for each possible base B in sequence it first calculates the number of digits of N when represented in base B, then checks whether N is divisible by the value represented by that same number of 1-digits in base B.

Input N Ask the user for the value of N. For(B,2,2N Loop from base 2 to 2N. We are guaranteed a solution at base N+1, and this suffices since N is at least 1. int(log(NB)/log(B Calculate the number of digits of N in base B, placing the result in Ans. This is equivalent to floor(log_B(N))+1. (B-1)/(B^Ans-1 The value represented by Ans consecutive 1-digits in base B, inverted. If fpart(N Check whether N is divisible by the value with Ans consecutive 1-digits, by multiplying it by the inverse and checking its fractional part. Skips over the End if it was divisible. End Continue the For loop, only if it was not divisible. The number of digits of N in base B is still in Ans. 

K (ngn/k), 24 bytes

{|/x{#{1=#?x}#y\x}'2+!x} 

Try it online!

• x{...}'2+!x call the inner {...} lambda on the input n, paired up with each number from 2..n+1
  • y\x convert the input to the current base
  • {1=#?x}# filter down to representations containing only a single unique digit
  • # return the length of this representation (0 if it contained multiple digits)
• {|/...} return the maximum across all potential bases

Pyth, 13 bytes

lhf!t{TjLQ}2h 

Try it online!

Java 8, 111 bytes

n->{int r=0,i=1,l;for(String t;++i<n+2;r=(l=t.length())>r&t.matches("(.)\\1*")?l:r)t=n.toString(n,i);return r;} 

Byte-count of 111 is also a rep-digit. ;)

Explanation:

Try it here.

n->{ // Method with Integer as parameter return-type int r=0, // Result-integer i=1, // Index-integer l; // Length-integer for(String t; // Temp-String ++i<n+2; // Loop from 2 to `n+2` (exclusive) r= // After every iteration, change `r` to: (l=t.length())>r // If the length of `t` is larger than the current `r` &t.matches("(.)\\1*")? // and the current `t` is a rep-digit: l // Change `r` to `l` (the length of the rep-digit) : // Else: r) // Leave `r` as is t=n.toString(n,i); // Set String representation of `n` in base-`i` to `t` // End of loop (implicit / single-line body) return r; // Return the result-integer } // End of method 

Java 8, 79 bytes

A lambda from Integer to Integer.

n->{int m,b=2,l;for(;;b++){for(m=n,l=0;m>0&m%b==n%b;l++)m/=b;if(m<1)return l;}} 

Ungolfed lambda

n -> { int m, b = 2, l; for (; ; b++) { for (m = n, l = 0; m > 0 & m % b == n % b; l++) m /= b; if (m < 1) return l; } } 

Checks radices in increasing order from 2 until a rep-digit radix is found. Relies on the fact that the smallest such radix will correspond to a representation with the most digits.

m is a copy of the input, b is the radix, and l is the number of digits checked (and ultimately the length of the radix-b representation).

Burlesque, 24 bytes

(see correct solution below)

J2jr@jbcz[{dgL[}m^>] 

See in action.

J2jr@ -- boiler plate to build a list from 2..N jbcz[ -- zip in N {dgL[}m^ -- calculate base n of everything and compute length >] -- find the maximum. 

At least if my intuition is right that a rep-digit representation will always be longest? Otherwise uhm...

J2jr@jbcz[{dg}m^:sm)L[>] :sm -- filter for "all elements are the same" 

Ruby, 60 bytes

->n{(2..n).filter_map{d=n.digits _1 !d.uniq[1]&&d.size}.max} 

Attempt This Online!