Hey I just did a quick web search and found this. I haven’t used the tool specifically before. However I recommend either searching the web for a similar tool or using a chatgpt like tool to create a python script that’ll achieve your end result. Sed and regex are cool and useful, but they’re only going to make it more difficult to achieve what you need.

This might work, but I think it is best to not tinker further if you already have a working script (especially one that you understand and can modify further if needed).

perl -pe 's/\[[^]]+\]\((?!https?)[^#]*#\K[^)]+(?=\))/lc $&=~s:%20|\d\K\.(?=\d):-:gr/ge'

Hmm, OP mentioned “Only edit what’s between parentheses” - don’t see anywhere that whole URL shouldn’t be changed…

I did it!! It also handles the case where an external link and internal link are on the same line :D

sed -E ':l;s/(\[[^]]*\]\()([^)#]*#[^)]*\))/\1\n\2/;Te;H;g;s/\n//;s/\n.*//;x;s/.*\n//;/^https?:/!{:h;s/^([^#]*#[^)]*)(%20|\.)([^)]*\))/\1-\3/;th;s/(#[^)]*\))/\L\1/;};tl;:e;H;z;x;s/\n//;'

Here is my annotated file

# Begin loop
:l;

# Bisect first link in pattern space into pattern space and append to hold space
# Example: `text [label](file#fragment)'
#   Pattern space: `file#fragment)'
#   Hold space: `text [label]('
# Steps:
#   1. Strategically insert \n
#       1a. If this fails, branch out
#   2. Append to hold space (this creates two \n's. It feels weird for the
#      first iteration, but that's ok)
#   3. Copy hold space to pattern space, remove first \n, then trim off
#      everything past the second \n
#   4. Swap pattern/hold, and trim off everything up to and incl the last \n
s/(\[[^]]*\]\()([^)#]*#[^)]*\))/\1\n\2/;
Te;
H;
g; s/\n//; s/\n.*//;
x; s/.*\n//;

# Modify only if it is an internal link
/^https?:/! {
    # Add hyphens
    :h;
    s/^([^#]*#[^)]*)(%20|\.)([^)]*\))/\1-\3/;
    th;
    # Make lowercase
    s/(#[^)]*\))/\L\1/;
};

# "conditional" branch so it checks the next conditional again
tl;

# Exit: join pattern space to hold space, then move to pattern space.
# Since the loop uses H instead of h, have to make sure hold space is empty
:e;
H;
z;
x; s/\n//;

skip the following substitute command if the line contains an http link in markdown format

Why you assume there’s only one link in the line?

Also, you perform substitutions in the whole URL instead only the fragment component.

Okay, here’s the command and a breakdown. I broke down every part of the command, not because I think you are dumb, but because reading these can be complicated and confusing. Additionally, detailed breakdowns like these have helped me in the past.

The command:

sed -ri 's|]\(#.+\)|\L&|; s|%20|-|g' /path/to/somefile

The breakdown:

sed - calls sed

-r - allows for the use of extended regular expressions

-i - edit the file given as an argument at the end of the command (note, the i flag must follow the r flag, or the extended regular expressions will not be evaluated)

Now the regex piece by piece. This command has two substitution regex to break down the goals into managable chunks.

Expression one is to convert the markdown links to lowercase. That expression is:

's|]\(#.+\)|\L&|;

The goal of this expression is to find markdown links, and to ignore https links. In your post you indicate the markdown links all start with a # symbol, so we don’t have to explicitly ignore the https as much as we just have to match all links starting with #. Here’s the breakdown:

' - begins the entire expression set. If you had to match the ' character in your expression you would begin the expression set with " instead of '.

s| - invoking find and replace (substitution). Note, Im using the | as a separator instead of the / for easier readability. In sed, you can use just about any separator you want in your syntax

]\(# - This is how we find the link we want to work on. In markdown, every link is preceded by ]( to indicate a closing of the link text and the opening of the actual url. In the expression, the ( is preceded by a \ because it is a special regex character. So \( tells sed to find an actual closing parentheses character. Finally the # will be the first character of the markdown links we want to convert to lowercase, as indicated by your example. The inclusion of the # insures no https links will be caught up in the processing.

.+ - this bit has two parts, . and +. These are two special regex characters. the . tells sed to find any character at all and the + tells it to find the preceding character one or more times. In the case of .+, it’s telling sed to find one or more of any characters. You might think this will eat ALL of the text in the document and make it all lowercase, but it will not because of the next part of the regex.

\) - this tells sed to find a closing parentheses. Like the opening parentheses, it is a special regex character and needs to be escaped with the backslash to tell sed to find an actual closing parentheses character. This is what stops the command from converting the entire document to lowercase, because when you combine the previous bit with this bit like so .+\), you’re telling sed to find one or more of any character UNTIL you find a closing parentheses.

| - This tells sed we’re done looking for text to match. The next bits are about how to modify/replace that text

\L - This tells sed to convert the given text to all lowercase

& - This is the given text to modify. In this case the & is a special mertacharacter that tells sed to modify the entire pattern matched in the matching portion of the expression. So when the & is preceded by the \L, this tells sed Take everything that was matched in the pattern matching expression and convert it to lowercase.

; - this tells sed that this is the end of the first expression, and that more are coming.

So all together, what this first expression does is: Find a closing bracket followed by an opening parentheses followed by a pound/hash symbol followed by one or more of any characters until finding a closing parentheses. Then convert that entire chunk of text to lowercase. Because symbols don’t have case you can just convert the entire matched pattern to lowercase. If there were specific parts that had to be kept case sensitive, then you’d have to match and modify more precisely.

The next expression is pretty easy, UNLESS any of your https links also include the string %20:

If no https links contain the %20 string, then this will do the trick:

s|%20|-|g'

s| - again opens the expression telling sed wer’re looking to substitute/modify text

%20 - tells sed to find exactly the character sequence %20

| - ends the pattern matching portion of the expression

- - tells sed to replace the matched pattern with the exact character -

| - tells sed that’s the end of the modification instructions

g - tells sed to do this globally throughout the document. In other words, to find all occurrances of the string %20 and replace them with the string -

' - tells sed that is the end of the expression(s) to be evaluated.

So all together, what this expression does is: Within the given document, find every occurrence of a percent symbol followed by the number two followed by the number zero and replace them with the dash character.

/path/to/somefile - tells sed what file to work on.

Part of using regex is understanding the contents of your own text, and with the information and examples given, this should work. However, if the markdown links have different formatting patterns, or as mentioned any of the https links have the %20 string in them, or other text in the document might falsely match, then you’d have to provide more information to get a more nuanced regex to match.

Edit: clarified the use of the & metacharacter.

Edit 2: clarified that the + metacharacter indicates finding the preceding character (or character set) one or more times.