Assembler. Algorithm for incrementing a decimal number

This code obviously uses recursion.

That's not the case. For recursion your INCREMENT routine would have to call itself which it doesn't. The INCREMENT subroutine simply iterates over the characters in the text.

You're right that there is room for improvement. I'll share these observations with you.

xor rax,rax
mov rax, 1

It's not useful to clear RAX right before loading it with a value that is going to overwrite the whole qword anyway.
Writing to the low dword of a 64-bit register will automatically zero out the high dword.

The above code simply becomes mov eax, 1. You can apply this several times using different registers.

mov byte[countN],5
sub rbx, [countN]
mov rdx, [countN]
mov eax, [index]

You have defined countN as a dword variable but the program is using it both as a byte and as a qword!
You have reserved a single byte for the index variable but your program is also using it as a dword!
Always use your variables for what size they really have. Don't count on the fact that your index variable happens to be the last item in the .BSS and that your program worked well because of this.

mov byte[number+59],"9"; Ten thousands
mov byte[number+60],"9"; Thousands
mov byte[number+61],"9"; Hundreds
mov byte[number+62],"9"; Tens
mov byte[number+63],"9"; Ones

You can initialize the integer number "99999" using fewer instructions:

mov  rax, "///99999"      (*)
mov  [number+56], rax

(*) The x86-64 architecture only allows 64-bit immediates on register loads. See this SO answer for more info.

mov rbx, 64 ;total of digits
sub rbx, [countN] ;sub number of digits used   
add rbx,number;add the base   

Calculating the address where the number starts only needs these 2 instructions, and because you need this in RSI, why not calculate it in RSI:

lea  esi, [number+64]
sub  esi, [countN]

  jz EQUAL
  jmp checkNEWdigit
EQUAL:

Code like this should use the opposite condition and shave off the extra jump:

  jnz checkNEWdigit
EQUAL:

I think the algorithm is very readable thanks to the labels.

You're right that it is readable, but then again it is also some kind of spaghetti code with all that jumping around!

If you can accept using another character like ":" for the non-occupied positions, then your INCREMENT subroutine would only need 1 comparison instead of the current 2. The trick is to choose a character that is above the character "9" in the ASCII set.
Below is my rewrite that reduces the number of instructions that are needed:

INCREMENT:
  cmp  byte [number+rax], "9"   ; "0123456789:"
  jb   .Increment
  mov  byte [number+rax], "0"
  ja   .NewDigit
  dec  eax
  jmp  INCREMENT
.NewDigit:
  inc  dword [countN]
.Increment:
  inc  byte [number+rax]
  ret

Please notice that creating a new digit happens in 2 steps: first "0" is written over the ":" and then that zero is incremented. Because creating a new digit happens rarely, this can't possibly make the code any worse. It does however produce clean code.

You've done well to not include code that checks for an overflow after the 64th digit. Who would still be around to see that happen?