Vou deixar uma breve explicação geral do projeto e dos arquivos e meu código final todo documentado

=== Abaixo meus códigos finais documentados ===

index.js

// Exporta a função 'contaPalavras' que recebe um texto como argumento e conta a ocorrência de palavras repetidas.
export function contaPalavras(texto) {
    
    // Extrai parágrafos do texto
    const paragrafos = extraiParagrafos(texto);

    // Mapeia os parágrafos para verificar palavras duplicadas
    const contagem = paragrafos.flatMap((paragrafo) => {
        if (!paragrafo) return []; // Se o parágrafo for vazio, retorna um array vazio
        return verificaPalavrasDuplicadas(paragrafo); // Verifica as palavras duplicadas no parágrafo
    });

    return contagem; // Retorna a contagem de palavras duplicadas
}

// Função para extrair parágrafos de um texto, convertendo o texto para minúsculas e dividindo-o por quebras de linha.
function extraiParagrafos(texto) {
    return texto.toLowerCase().split('\n');
}

// Função para limpar uma palavra, removendo pontuações e caracteres especiais.
function limpaPalavras(palavra) {
    return palavra.replace(/[.,\/#!$%\^&\*;:{}=\-_`~()]/g, '');
}

// Função para verificar palavras duplicadas em um parágrafo.
function verificaPalavrasDuplicadas(texto) {
    const listaPalavras = texto.split(' '); // Divide o parágrafo em palavras

    const resultado = {}; // Objeto que armazenará a contagem de palavras

    // Itera sobre cada palavra do parágrafo
    listaPalavras.forEach(palavra => {
        if (palavra.length >= 3) { // Considera apenas palavras com 3 ou mais caracteres
            const palavraLimpa = limpaPalavras(palavra); // Limpa a palavra de caracteres especiais
            resultado[palavraLimpa] = (resultado[palavraLimpa] || 0) + 1; // Incrementa a contagem da palavra limpa no objeto resultado
        }
    });

    return resultado; // Retorna o objeto com a contagem de palavras
}

cli.js

import fs from 'fs'; // Importa o módulo 'fs' para manipulação de arquivos
import path from 'path'; // Importa o módulo 'path' para manipulação de caminhos de arquivos
import trataErros from './erros/funcoesErro.js'; // Importa a função para tratamento de erros
import { contaPalavras } from './index.js'; // Importa a função de contagem de palavras
import { montaSaidaArquivo } from './helpers.js'; // Importa a função que monta a saída para arquivo
import { Command } from 'commander'; // Importa a biblioteca commander para criação de comandos CLI
import chalk from 'chalk'; // Importa a biblioteca chalk para colorir o texto no terminal

const program = new Command(); // Cria uma nova instância do comando CLI

// Configuração do comando CLI com opções e argumentos
program
  .version('0.0.1') // Define a versão da CLI
  .option('-t, --texto <string>', 'caminho do texto a ser processado') // Define a opção de caminho do texto
  .option('-d, --destino <string>', 'caminho da pasta onde salvar o arquivo de resultados') // Define a opção de caminho de destino
  .action((options) => { // Define a ação a ser executada com as opções fornecidas pelo usuário

      const { texto, destino } = options; // Desestrutura as opções para obter os caminhos de texto e destino

      if (!texto || !destino) { // Verifica se ambos os caminhos foram fornecidos
        console.error(chalk.red('erro: favor inserir caminho de origem e destino')); // Exibe erro no console se faltar algum caminho
        program.help(); // Exibe a ajuda do programa
        return; // Sai da função
      }

      const caminhoTexto = path.resolve(texto); // Resolve o caminho absoluto do texto
      const caminhoDestino = path.resolve(destino); // Resolve o caminho absoluto do destino

      try {
        processaArquivo(caminhoTexto, caminhoDestino); // Processa o arquivo com os caminhos fornecidos
        console.log(chalk.green('Texto processado com sucesso')); // Exibe mensagem de sucesso
      } catch(erro) {
          console.log('ocorreu um erro no processamento', erro); // Exibe erro em caso de falha no processamento
      }
});

program.parse(); // Faz o parse dos argumentos da linha de comando

// Função para processar o arquivo de texto, lendo seu conteúdo e contando palavras duplicadas
function processaArquivo(texto, destino) {
    fs.readFile(texto, 'utf-8', (erro, texto) => { // Lê o arquivo de texto no encoding UTF-8
        try {
            if (erro) throw erro; // Lança o erro se houver problema ao ler o arquivo
            const resultado = contaPalavras(texto); // Conta as palavras duplicadas no texto
            criaESalvaArquivo(resultado, destino); // Cria e salva o resultado em um arquivo de destino
        } catch(erro) {
            trataErros(erro); // Trata o erro usando a função personalizada de tratamento de erros
        }
    });    
}

// Função para criar e salvar o arquivo com o resultado da contagem de palavras duplicadas
function criaESalvaArquivo(listaPalavras, endereco) {
    
    const arquivoNovo = `${endereco}/resultado.txt`; // Define o nome do arquivo de saída
    const textoPalavras = montaSaidaArquivo(listaPalavras); // Gera o texto formatado para o arquivo

    fs.promises.writeFile(arquivoNovo, textoPalavras) // Usa o método de Promises do 'fs' para escrever o arquivo
     .then(() => {
         console.log('arquivo criado'); // Exibe mensagem de sucesso ao criar o arquivo
     }).catch((erro) => {
        throw erro; // Lança o erro em caso de falha ao escrever o arquivo
     }).finally(() => console.log('operação finalizada')); // Exibe mensagem de finalização da operação
}

helpers.js

// Função para filtrar palavras duplicadas em um parágrafo.
// Retorna uma lista de palavras que aparecem mais de uma vez.
function filtraOcorrencias(paragrafo) {
    return Object.keys(paragrafo).filter(chave => paragrafo[chave] > 1);
}

// Função para formatar a saída dos resultados da contagem de palavras duplicadas para salvar em um arquivo.
function montaSaidaArquivo(listaPalavras) {

    let textoFinal = ''; // String que armazenará o texto formatado final

    // Itera sobre cada parágrafo processado
    listaPalavras.forEach((paragrafo, indice) => {
        
        const duplicadas = filtraOcorrencias(paragrafo).join(', '); // Filtra e junta as palavras duplicadas em uma string
        textoFinal += `palavras duplicadas no parágrafo ${indice + 1}: ${duplicadas} \n`; // Adiciona o resultado formatado ao texto final
    });

    return textoFinal; // Retorna o texto final formatado
}

// Exporta a função montaSaidaArquivo para ser usada em outros módulos
export { montaSaidaArquivo }

funcoesErro.js

// Exporta a função que trata os erros ocorridos durante a execução da aplicação
export default function trataErros(erro) {
    
    // Verifica se o erro é de arquivo não encontrado
    if(erro.code === 'ENOENT') {
        throw new Error('Arquivo não encontrado'); // Lança um novo erro com uma mensagem personalizada
    } else { 
        return 'Erro na aplicação'; // Retorna uma mensagem genérica de erro para outros tipos de erro
    }
}