Imprimir padrão correspondente em um arquivo junto com linhas correspondentes

Uma awkideia:

awk '
BEGIN   { sep1 = "\t"; sep2 = "," }                       # predefine our separators; modify as desired

FNR==NR { ptns[$0]; next }                                # 1st file: save each line as a new index in our ptns[] array

        { sfx = ""                                        # 2nd file: reset our suffix

          for (ptn in ptns)                               # loop through the indices (aka patterns) of the ptns[] array
              if (index($0,ptn))                          # if the pattern exists in the current line (ie, index() returns a value > 0) then ...
                 sfx = sfx (sfx == "" ? "" : sep2) ptn    # append the pattern to our suffix

          if (sfx != "")                                  # if the suffix is not blank then we found at least one match so ...
             print $0 sep1 sfx                            # print current line and append the suffix
        }
' pattern.txt file.txt

Alternativamente, coloque o corpo do awkscript em um arquivo e acesse via awk -f ...:

$ cat my_grep.awk
BEGIN   { sep1 = "\t"; sep2 = "," }
FNR==NR { ptns[$0]; next }
        { sfx = ""
          for (ptn in ptns)
              if (index($0,ptn))
                 sfx = sfx (sfx == "" ? "" : sep2) ptn
          if (sfx != "")
             print $0 sep1 sfx
        }

$ awk -f my_grep.awk pattern.txt file.txt

NOTAS:

• assume que as linhas em patterns.txtnão têm nenhum espaço em branco inicial/final, o que causaria index()falha na chamada
• (ptn in ptns)não garante a ordem em que os padrões são processados, o que significa que não há garantia da ordem dos padrões quando impressos no final da linha; embora código adicional possa ser adicionado para atender a um requisito de ordem , o OP precisaria fornecer mais detalhes para incluir como lidar com padrões duplicados e/ou sobrepostos (por exemplo, ae ascorresponderia na mesma index()posição, então qual padrão seria considerado a correspondência real?)
• como index()só encontraremos a 1ª ocorrência de um padrão, e não fazemos nenhuma tentativa de correspondência além dessa primeira correspondência, essa abordagem apenas nos diz que há pelo menos uma correspondência; codificação adicional seria necessária para determinar o número de correspondências, mas também exigiria detalhes adicionais do OP sobre como processar padrões duplicados e/ou sobrepostos (por exemplo, quantas vezes 4e 44correspondem a 44444444?)

Ambas as abordagens geram:

abc$(SEQ)asdasd asd
efg hij$(SEQ)asdasdasd$(SEQ)zzzzzz  asd
op$(SEQ)44444444    444
qrs$(SEQ)777    777
qrs$(SEQ)777444 444,777
asdsd777hdhfgjdfasd asd,777

Como qualquer formato reconhecível é permitido, a solução mais simples é substituir as sequências ANSI emitidas pelo grep diretamente por qualquer separador que você quiser, como uma tabulação:

$grep --color=always -f pattern.txt file.txt | \
  sed -E 's/(\x1b\[[0-9;]*[A-Za-z])+/\t/g'
abc$(SEQ) asd asd
efg hij$(SEQ) asd asd asd $(SEQ)zzzzzz
op$(SEQ) 444 444 44
qrs$(SEQ) 777
qrs$(SEQ) 777 444
    asd sd 777 hdhfgjdf asd

Também é possível capturar cada correspondência entre a sequência ANSI inicial e final, por exemplo, aqui eu envolvo cada correspondência dentro[]

$grep --color=always -f pattern.txt file.txt | \
  sed -E -e 's#\x1b\[m#]\t#g'  -e 's#\x1b\[[0-9;]+m#\t[#g'
abc$(SEQ) [asd] [asd]
efg hij$(SEQ) [asd] [asd] [asd] $(SEQ)zzzzzz
op$(SEQ) [444] [444] 44
qrs$(SEQ) [777]
qrs$(SEQ) [777] [444]
    [asd] sd [777] hdhfgjdf [asd]

Para imprimir os padrões no final você pode usar algo assim

$grep --color=always -f pattern.txt file.txt | while read -r line; do
    printf "%s\t=== Patterns: " "$line"
    echo "$line" | perl -nE 'while (/\x1b\[[0-9;]+m(.*?)\x1b\[m/g) {
        print "$1 "; }; print "\n";'
done

abc$(SEQ)asdasd === Padrões: asd asd
efg hij$(SEQ)asdasdasd$(SEQ)zzzzzz === Padrões: asd asd asd
op$(SEQ)44444444 === Padrões: 444 444
qrs$(SEQ)777 === Padrões: 777
qrs$(SEQ)777444 === Padrões: 777 444
asdsd777hdhfgjdfasd === Padrões: asd 777 asd

$grep --color=always -f pattern.txt file.txt | while read line; do \
    printf "$line\t=== Patterns: " | sed -E 's/\x1b\[[0-9;]*[A-Za-z]//g'
    echo "$line" | sed -E 's/^.*\x1b\[[0-9;]+m(.+)\x1b\[m/\1/g'
done
abc$(SEQ)asdasd === Padrões: asd
efg hij$(SEQ)asdasdasd$(SEQ)zzzzzz === Padrões: asd$(SEQ)zzzzzz
op$(SEQ)44444444 === Padrões: 44444
qrs$(SEQ)777 === Padrões: 777
qrs$(SEQ)777444 === Padrões: 444
asdsd777hdhfgjdfasd === Padrões: asd

Se você quiser preservar a cor para uso posterior, você também pode fazer isso diretamente

$ grep --color=always -f pattern.txt file.txt > output.txt
$ cat output.txt

Para fazer isso em Perl, use isto:

perl -lne '
BEGIN {
    chomp( @pats = `cat pattern.txt` );
    $pat = join "|", @pats;
}
if ( @matches = m{($pat)}g ) {
    %seen = ();
    @uniq = grep !$seen{$_}++, @matches;
    $uniq = join ",", @uniq;
    print "$_\t$uniq";
}' file.txt

Saída:

abc$(SEQ)asdasd      asd
efg hij$(SEQ)asdasdasd$(SEQ)zzzzzz      asd
op$(SEQ)44444444        444
qrs$(SEQ)777    777
qrs$(SEQ)777444 777,444
asdsd777hdhfgjdfasd     asd,777

O "one-liner" do Perl usa estes sinalizadores de linha de comando:
-e: Diz ao Perl para procurar código em linha, em vez de em um arquivo.
-n: Faz um loop na entrada, uma linha de cada vez, atribuindo-a $_por padrão.
-l: Remove o separador de linha de entrada ( "\n"por padrão no *NIX) antes de executar o código em linha e o anexa ao imprimir.

O regex usa este modificador:
g: Corresponde ao padrão repetidamente.

chomp( @pats = `cat pattern.txt` );

A linha acima lê o conteúdo do pattern.txtarquivo em uma matriz @patse remove as quebras de linha ( chomp).

$pat = join "|", @pats;: Une os padrões em uma única sequência, delimitada pelo operador |(= OR ).
@matches = m{($pat)}g: compara os padrões repetidamente ( m{...}g) com a linha atual lida de file.txt. Todas as correspondências são armazenadas em uma matriz @matches(que pode conter repetições do mesmo padrão, se ocorrer mais de uma vez).
if ( @matches = ... ): @matchesavalia TRUEse há pelo menos uma correspondência.
@uniq = grep !$seen{$_}++, @matches;: Torna as correspondências únicas e as armazena em @uniquma matriz.
$uniq = join ",", @uniq;: Une as correspondências únicas em uma vírgula e armazena o resultado em uma única sequência $uniq.

Veja também:

• perldoc perlrun: como executar o interpretador Perl: opções de linha de comando
• perldoc perlre: Expressões regulares Perl (regexes)
• perldoc perlrequick: Início rápido de expressões regulares em Perl