Smart Track Duplicator - Help With Script

Hi Phil and Raphael,

I stumbled upon this post and decided to update your script and modify it to work with my naming conventions.
Maybe you'll find a use for it - it should be quite easy to modify too. I still need to do some testing on it, but so far it seems to work quite well.

The script gets all track names from the session and finds the correct numbering for the new track(s).
It also accounts for playlist numbering (I tend to name my tracks track name.01 from the get go). So if you duplicate a track with playlist numbering, it will add .01 to that track name.

If you have tracks called Guitar 1, Guitar 2, Guitar 3, Guitar 4 and decide to duplicate Guitar 1, it will call that track Guitar 5.
Same logic applies with playlist numbering - if you have Guitar 1.05, Guitar 2.01, Guitar 3.11 and duplicate Guitar 1.05, it becomes Guitar 4.01.

function duplicateTracksSmartRename() {
    const numberOfDups = Number(
        sf.interaction.displayDialog({
            title: "Duplicate Tracks (Smart Rename)",
            prompt: "How many duplicates?",
            defaultAnswer: "1",
            buttons: ["Cancel", "Ok"],
            defaultButton: "Ok",
            cancelButton: "Cancel",
        }).text
    );

    sf.ui.proTools.appActivateMainWindow();
    sf.ui.proTools.mainWindow.invalidate();

    const tracksToDup = sf.ui.proTools.selectedTrackNames;

    // Duplicate tracks
    sf.ui.proTools.trackDuplicateSelected({
        duplicateActivePlaylist: false,
        duplicateAlternatePlaylists: false,
        duplicateAutomation: false,
        duplicateGroupAssignments: false,
        duplicateInserts: true,
        duplicateSends: true,
        insertAfterLastSelectedTrack: true,
        numberOfDuplicates: numberOfDups
    });

    sf.ui.proTools.mainWindow.invalidate();

    // Get the currently selected tracks (these are the newly created duplicates)
    const newlyCreatedTracks = sf.ui.proTools.selectedTrackNames;
    
    //log(`Original tracks to duplicate: ${tracksToDup.join(', ')}`);
    //log(`Newly created tracks (selected): ${newlyCreatedTracks.join(', ')}`);

    // Get ALL tracks in the session to check for existing numbers
    const allTracksInSession = sf.ui.proTools.trackGetAllTracks().names;
    
    //log(`All tracks in session: ${allTracksInSession.join(', ')}`);

    // Keep track of numbers we've already assigned to avoid conflicts
    const assignedNumbers = {};
    
    // Rename only the newly created duplicate tracks
    tracksToDup.forEach((originalTrackName, originalIndex) => {
        //log(`Processing original track: ${originalTrackName}`);
        
        // Check if the original track has playlist numbering (.XX format)
        const hasPlaylistNumber = /\.\d{2}$/.test(originalTrackName);
        //log(`Original track has playlist numbering: ${hasPlaylistNumber}`);
        
        // Get the base name from the original track
        let baseName = originalTrackName.replace(/\.\d{2}$/, "").replace(/\s?\d+$/, "");
        
        //log(`Base name: ${baseName}`);
        
        // Find all existing track numbers for this base name in the entire session
        const existingNumbers = allTracksInSession
            .filter(trackName => {
                // Get the base name of this track
                const trackBaseName = trackName.replace(/\.dup\d+/, "").replace(/\.\d{2}$/, "").replace(/\s?\d+$/, "");
                return trackBaseName === baseName;
            })
            .map(trackName => {
                // Extract the number from the track name (after removing .dup and playlist)
                const withoutDupAndPlaylist = trackName.replace(/\.dup\d+/, "").replace(/\.\d{2}$/, "");
                const numberMatch = withoutDupAndPlaylist.match(/\s?(\d+)$/);
                return numberMatch ? parseInt(numberMatch[1]) : 1;
            });
        
        // Include previously assigned numbers from this session
        const allUsedNumbers = [...existingNumbers, ...(assignedNumbers[baseName] || [])];
        const highestExistingNumber = allUsedNumbers.length > 0 ? Math.max(...allUsedNumbers) : 0;
        
        //log(`Existing numbers for ${baseName}: ${existingNumbers.join(', ')}`);
        //log(`Previously assigned numbers: ${(assignedNumbers[baseName] || []).join(', ')}`);
        //log(`Highest existing number: ${highestExistingNumber}`);
        
        // Initialize the assigned numbers array for this base name if it doesn't exist
        if (!assignedNumbers[baseName]) {
            assignedNumbers[baseName] = [];
        }
        
        // Find the duplicates that were created from this specific original track
        const duplicatesFromThisTrack = newlyCreatedTracks.filter(trackName => {
            // Check if this duplicate was created from the current original track
            // Remove .dup# but keep the playlist number
            const withoutDup = trackName.replace(/\.dup\d+/, "");
            const hasDup = trackName.includes('.dup');
            const matches = withoutDup === originalTrackName;
            
            //log(`Checking track: "${trackName}"`);
            //log(`  Without dup: "${withoutDup}"`);
            //log(`  Has .dup: ${hasDup}`);
            //log(`  Matches original: ${matches}`);
            //log(`  Result: ${hasDup && matches}`);
            
            return hasDup && matches;
        });
        
        //log(`Found ${duplicatesFromThisTrack.length} duplicates: ${duplicatesFromThisTrack.join(', ')}`);
        
        // Rename each duplicate, starting from the next available number
        duplicatesFromThisTrack.forEach((dupTrackName, dupIndex) => {
            const newNumber = highestExistingNumber + dupIndex + 1;
            
            // Track this number as assigned
            assignedNumbers[baseName].push(newNumber);
            
            // Only add playlist numbering if the original track had it
            const newName = hasPlaylistNumber 
                ? baseName + " " + newNumber + ".01"
                : baseName + " " + newNumber;
            
            //log(`Renaming: "${dupTrackName}" -> "${newName}"`);
            
            if (dupTrackName === newName) {
                log("Names are identical, skipping rename");
                return;
            }
            
            sf.app.proTools.renameTrack({
                oldName: dupTrackName,
                newName: newName
            });
        });
    });
}

duplicateTracksSmartRename();