@synthetic-ai/premiere-mcp 2.0.0

package/dist/tools/track-management.js

@@ -0,0 +1,787 @@
+import { buildToolScript, escapeForExtendScript } from "../bridge/script-builder.js";
+import { sendCommand } from "../bridge/file-bridge.js";
+export function getTrackManagementTools(bridgeOptions) {
+    return {
+        rename_audio_track: {
+            description: "Rename an audio track in the active sequence.",
+            parameters: {
+                type: "object",
+                properties: {
+                    track_index: { type: "number", description: "Audio track index (0-based)" },
+                    name: { type: "string", description: "New name for the track" },
+                },
+                required: ["track_index", "name"],
+            },
+            handler: async (args) => {
+                const script = buildToolScript(`
+          var seq = app.project.activeSequence;
+          if (!seq) return __error("No active sequence");
+          var track = seq.audioTracks[${args.track_index}];
+          if (!track) return __error("Audio track not found at index ${args.track_index}");
+          track.name = "${escapeForExtendScript(args.name)}";
+          return __result({ renamed: true, trackIndex: ${args.track_index}, newName: "${escapeForExtendScript(args.name)}" });
+        `);
+                return sendCommand(script, bridgeOptions);
+            },
+        },
+        mute_audio_track: {
+            description: "Mute or unmute an audio track.",
+            parameters: {
+                type: "object",
+                properties: {
+                    track_index: { type: "number", description: "Audio track index (0-based)" },
+                    muted: { type: "boolean", description: "True to mute, false to unmute" },
+                },
+                required: ["track_index", "muted"],
+            },
+            handler: async (args) => {
+                const script = buildToolScript(`
+          var seq = app.project.activeSequence;
+          if (!seq) return __error("No active sequence");
+          var track = seq.audioTracks[${args.track_index}];
+          if (!track) return __error("Audio track not found at index ${args.track_index}");
+          track.setMute(${args.muted ? 1 : 0});
+          return __result({ muted: ${args.muted}, trackIndex: ${args.track_index}, trackName: track.name });
+        `);
+                return sendCommand(script, bridgeOptions);
+            },
+        },
+        lock_audio_track: {
+            description: "Lock or unlock an audio track to prevent accidental edits.",
+            parameters: {
+                type: "object",
+                properties: {
+                    track_index: { type: "number", description: "Audio track index (0-based)" },
+                    locked: { type: "boolean", description: "True to lock, false to unlock" },
+                },
+                required: ["track_index", "locked"],
+            },
+            handler: async (args) => {
+                const script = buildToolScript(`
+          var seq = app.project.activeSequence;
+          if (!seq) return __error("No active sequence");
+          var track = seq.audioTracks[${args.track_index}];
+          if (!track) return __error("Audio track not found at index ${args.track_index}");
+          if (typeof track.setLock === "function") { track.setLock(${args.locked}); } else { track.locked = ${args.locked}; }
+          return __result({ locked: ${args.locked}, trackIndex: ${args.track_index}, trackName: track.name });
+        `);
+                return sendCommand(script, bridgeOptions);
+            },
+        },
+        set_audio_track_target: {
+            description: "Set whether an audio track is targeted for recording or editing operations.",
+            parameters: {
+                type: "object",
+                properties: {
+                    track_index: { type: "number", description: "Audio track index (0-based)" },
+                    targeted: { type: "boolean", description: "True to target this track, false to untarget" },
+                },
+                required: ["track_index", "targeted"],
+            },
+            handler: async (args) => {
+                const script = buildToolScript(`
+          var seq = app.project.activeSequence;
+          if (!seq) return __error("No active sequence");
+          var track = seq.audioTracks[${args.track_index}];
+          if (!track) return __error("Audio track not found at index ${args.track_index}");
+          if (typeof track.setTargeted === "function") { track.setTargeted(${args.targeted}, false); } else { track.targeted = ${args.targeted}; }
+          return __result({ targeted: ${args.targeted}, trackIndex: ${args.track_index}, trackName: track.name });
+        `);
+                return sendCommand(script, bridgeOptions);
+            },
+        },
+        rename_video_track: {
+            description: "Rename a video track in the active sequence.",
+            parameters: {
+                type: "object",
+                properties: {
+                    track_index: { type: "number", description: "Video track index (0-based)" },
+                    name: { type: "string", description: "New name for the track" },
+                },
+                required: ["track_index", "name"],
+            },
+            handler: async (args) => {
+                const script = buildToolScript(`
+          var seq = app.project.activeSequence;
+          if (!seq) return __error("No active sequence");
+          var track = seq.videoTracks[${args.track_index}];
+          if (!track) return __error("Video track not found at index ${args.track_index}");
+          track.name = "${escapeForExtendScript(args.name)}";
+          return __result({ renamed: true, trackIndex: ${args.track_index}, newName: "${escapeForExtendScript(args.name)}" });
+        `);
+                return sendCommand(script, bridgeOptions);
+            },
+        },
+        mute_video_track: {
+            description: "Mute or unmute a video track (hide/show its output).",
+            parameters: {
+                type: "object",
+                properties: {
+                    track_index: { type: "number", description: "Video track index (0-based)" },
+                    muted: { type: "boolean", description: "True to mute (hide), false to unmute (show)" },
+                },
+                required: ["track_index", "muted"],
+            },
+            handler: async (args) => {
+                const script = buildToolScript(`
+          var seq = app.project.activeSequence;
+          if (!seq) return __error("No active sequence");
+          var track = seq.videoTracks[${args.track_index}];
+          if (!track) return __error("Video track not found at index ${args.track_index}");
+          track.setMute(${args.muted ? 1 : 0});
+          return __result({ muted: ${args.muted}, trackIndex: ${args.track_index}, trackName: track.name });
+        `);
+                return sendCommand(script, bridgeOptions);
+            },
+        },
+        lock_video_track: {
+            description: "Lock or unlock a video track to prevent accidental edits.",
+            parameters: {
+                type: "object",
+                properties: {
+                    track_index: { type: "number", description: "Video track index (0-based)" },
+                    locked: { type: "boolean", description: "True to lock, false to unlock" },
+                },
+                required: ["track_index", "locked"],
+            },
+            handler: async (args) => {
+                const script = buildToolScript(`
+          var seq = app.project.activeSequence;
+          if (!seq) return __error("No active sequence");
+          var track = seq.videoTracks[${args.track_index}];
+          if (!track) return __error("Video track not found at index ${args.track_index}");
+          if (typeof track.setLock === "function") { track.setLock(${args.locked}); } else { track.locked = ${args.locked}; }
+          return __result({ locked: ${args.locked}, trackIndex: ${args.track_index}, trackName: track.name });
+        `);
+                return sendCommand(script, bridgeOptions);
+            },
+        },
+        set_video_track_target: {
+            description: "Set whether a video track is targeted for editing operations.",
+            parameters: {
+                type: "object",
+                properties: {
+                    track_index: { type: "number", description: "Video track index (0-based)" },
+                    targeted: { type: "boolean", description: "True to target this track, false to untarget" },
+                },
+                required: ["track_index", "targeted"],
+            },
+            handler: async (args) => {
+                const script = buildToolScript(`
+          var seq = app.project.activeSequence;
+          if (!seq) return __error("No active sequence");
+          var track = seq.videoTracks[${args.track_index}];
+          if (!track) return __error("Video track not found at index ${args.track_index}");
+          if (typeof track.setTargeted === "function") { track.setTargeted(${args.targeted}, false); } else { track.targeted = ${args.targeted}; }
+          return __result({ targeted: ${args.targeted}, trackIndex: ${args.track_index}, trackName: track.name });
+        `);
+                return sendCommand(script, bridgeOptions);
+            },
+        },
+        set_track_output: {
+            description: "Set the output channel assignment for an audio track.",
+            parameters: {
+                type: "object",
+                properties: {
+                    track_index: { type: "number", description: "Audio track index (0-based)" },
+                    output_channels: { type: "number", description: "Output channel assignment index" },
+                },
+                required: ["track_index", "output_channels"],
+            },
+            handler: async (args) => {
+                const script = buildToolScript(`
+          var seq = app.project.activeSequence;
+          if (!seq) return __error("No active sequence");
+          var track = seq.audioTracks[${args.track_index}];
+          if (!track) return __error("Audio track not found at index ${args.track_index}");
+          var outputSet = false;
+          if (track.components) {
+            for (var ci = 0; ci < track.components.numItems; ci++) {
+              var comp = track.components[ci];
+              if (comp.matchName === "audioOutputRouting" || comp.displayName === "Output Routing") {
+                for (var pi = 0; pi < comp.properties.numItems; pi++) {
+                  try { comp.properties[pi].setValue(${args.output_channels}, true); outputSet = true; break; } catch(e) {}
+                }
+                break;
+              }
+            }
+          }
+          return __result({ trackIndex: ${args.track_index}, trackName: track.name, requestedOutput: ${args.output_channels},
+            outputSet: outputSet, note: outputSet ? "Output routing set." : "Output routing component not accessible via ExtendScript in this PP version. Use the Audio Track Mixer to set output routing manually." });
+        `);
+                return sendCommand(script, bridgeOptions);
+            },
+        },
+        get_track_output: {
+            description: "Get the output channel assignment for an audio track.",
+            parameters: {
+                type: "object",
+                properties: {
+                    track_index: { type: "number", description: "Audio track index (0-based)" },
+                },
+                required: ["track_index"],
+            },
+            handler: async (args) => {
+                const script = buildToolScript(`
+          var seq = app.project.activeSequence;
+          if (!seq) return __error("No active sequence");
+          var track = seq.audioTracks[${args.track_index}];
+          if (!track) return __error("Audio track not found at index ${args.track_index}");
+          var outputInfo = { trackIndex: ${args.track_index}, trackName: track.name, clipCount: track.clips.numItems };
+          if (track.components) {
+            for (var ci = 0; ci < track.components.numItems; ci++) {
+              var comp = track.components[ci];
+              if (comp.matchName === "audioOutputRouting" || comp.displayName === "Output Routing") {
+                outputInfo.outputRoutingComponent = comp.displayName;
+                var vals = [];
+                for (var pi = 0; pi < comp.properties.numItems; pi++) {
+                  try { vals.push({ name: comp.properties[pi].displayName, value: comp.properties[pi].getValue() }); } catch(e) {}
+                }
+                outputInfo.properties = vals;
+                break;
+              }
+            }
+          }
+          return __result(outputInfo);
+        `);
+                return sendCommand(script, bridgeOptions);
+            },
+        },
+        select_all_on_track: {
+            description: "Select all clips on a specific track.",
+            parameters: {
+                type: "object",
+                properties: {
+                    track_type: { type: "string", description: "Track type: 'video' or 'audio'" },
+                    track_index: { type: "number", description: "Track index (0-based)" },
+                },
+                required: ["track_type", "track_index"],
+            },
+            handler: async (args) => {
+                const script = buildToolScript(`
+          var seq = app.project.activeSequence;
+          if (!seq) return __error("No active sequence");
+          var trackType = "${escapeForExtendScript(args.track_type)}";
+          var track = trackType === "video" ? seq.videoTracks[${args.track_index}] : seq.audioTracks[${args.track_index}];
+          if (!track) return __error("Track not found at index ${args.track_index}");
+          var count = 0;
+          for (var i = 0; i < track.clips.numItems; i++) {
+            track.clips[i].setSelected(true, true);
+            count++;
+          }
+          return __result({ selected: count, trackIndex: ${args.track_index}, trackType: trackType, trackName: track.name });
+        `);
+                return sendCommand(script, bridgeOptions);
+            },
+        },
+        get_clips_on_track: {
+            description: "Get information about all clips on a specific track.",
+            parameters: {
+                type: "object",
+                properties: {
+                    track_type: { type: "string", description: "Track type: 'video' or 'audio'" },
+                    track_index: { type: "number", description: "Track index (0-based)" },
+                },
+                required: ["track_type", "track_index"],
+            },
+            handler: async (args) => {
+                const script = buildToolScript(`
+          var seq = app.project.activeSequence;
+          if (!seq) return __error("No active sequence");
+          var trackType = "${escapeForExtendScript(args.track_type)}";
+          var track = trackType === "video" ? seq.videoTracks[${args.track_index}] : seq.audioTracks[${args.track_index}];
+          if (!track) return __error("Track not found at index ${args.track_index}");
+          var clips = [];
+          for (var i = 0; i < track.clips.numItems; i++) {
+            var c = track.clips[i];
+            clips.push({
+              nodeId: c.nodeId,
+              name: c.name,
+              clipIndex: i,
+              startSeconds: __ticksToSeconds(c.start.ticks),
+              endSeconds: __ticksToSeconds(c.end.ticks),
+              durationSeconds: __ticksToSeconds(c.duration.ticks),
+              inPointSeconds: __ticksToSeconds(c.inPoint.ticks),
+              outPointSeconds: __ticksToSeconds(c.outPoint.ticks),
+              mediaType: c.mediaType
+            });
+          }
+          return __result({
+            trackType: trackType,
+            trackIndex: ${args.track_index},
+            trackName: track.name,
+            clipCount: clips.length,
+            clips: clips
+          });
+        `);
+                return sendCommand(script, bridgeOptions);
+            },
+        },
+        find_gaps: {
+            description: "Find gaps (empty spaces) on a track in the timeline.",
+            parameters: {
+                type: "object",
+                properties: {
+                    track_type: { type: "string", description: "Track type: 'video' or 'audio'" },
+                    track_index: { type: "number", description: "Track index (0-based)" },
+                },
+                required: ["track_type", "track_index"],
+            },
+            handler: async (args) => {
+                const script = buildToolScript(`
+          var seq = app.project.activeSequence;
+          if (!seq) return __error("No active sequence");
+          var trackType = "${escapeForExtendScript(args.track_type)}";
+          var track = trackType === "video" ? seq.videoTracks[${args.track_index}] : seq.audioTracks[${args.track_index}];
+          if (!track) return __error("Track not found at index ${args.track_index}");
+          var clipCount = track.clips.numItems;
+          var clipData = [];
+          for (var i = 0; i < clipCount; i++) {
+            var c = track.clips[i];
+            clipData.push({ startTicks: parseFloat(c.start.ticks), endTicks: parseFloat(c.end.ticks) });
+          }
+          clipData.sort(function(a, b) { return a.startTicks - b.startTicks; });
+          var gaps = [];
+          for (var i = 0; i < clipData.length - 1; i++) {
+            var gapStartTicks = clipData[i].endTicks;
+            var gapEndTicks = clipData[i + 1].startTicks;
+            if (gapEndTicks > gapStartTicks + 1000) {
+              gaps.push({
+                index: gaps.length,
+                startSeconds: __ticksToSeconds(gapStartTicks.toString()),
+                endSeconds: __ticksToSeconds(gapEndTicks.toString()),
+                durationSeconds: __ticksToSeconds((gapEndTicks - gapStartTicks).toString()),
+                afterClipIndex: i,
+                beforeClipIndex: i + 1
+              });
+            }
+          }
+          return __result({
+            trackType: trackType,
+            trackIndex: ${args.track_index},
+            trackName: track.name,
+            clipCount: clipCount,
+            gapCount: gaps.length,
+            gaps: gaps
+          });
+        `);
+                return sendCommand(script, bridgeOptions);
+            },
+        },
+        close_gap: {
+            description: "Close a specific gap on a track. Uses QE DOM extract to ripple-delete the gap range.",
+            parameters: {
+                type: "object",
+                properties: {
+                    track_type: { type: "string", description: "Track type: 'video' or 'audio'" },
+                    track_index: { type: "number", description: "Track index (0-based)" },
+                    gap_index: { type: "number", description: "Gap index as returned by find_gaps (0-based)" },
+                },
+                required: ["track_type", "track_index", "gap_index"],
+            },
+            handler: async (args) => {
+                const script = buildToolScript(`
+          var seq = app.project.activeSequence;
+          if (!seq) return __error("No active sequence");
+          var trackType = "${escapeForExtendScript(args.track_type)}";
+          var track = trackType === "video" ? seq.videoTracks[${args.track_index}] : seq.audioTracks[${args.track_index}];
+          if (!track) return __error("Track not found at index ${args.track_index}");
+          var clipData = [];
+          for (var i = 0; i < track.clips.numItems; i++) {
+            var c = track.clips[i];
+            clipData.push({ startTicks: parseFloat(c.start.ticks), endTicks: parseFloat(c.end.ticks) });
+          }
+          clipData.sort(function(a, b) { return a.startTicks - b.startTicks; });
+          var gaps = [];
+          for (var i = 0; i < clipData.length - 1; i++) {
+            var gapStartTicks = clipData[i].endTicks;
+            var gapEndTicks = clipData[i + 1].startTicks;
+            if (gapEndTicks > gapStartTicks + 1000) {
+              gaps.push({ startTicks: gapStartTicks, endTicks: gapEndTicks });
+            }
+          }
+          var gapIdx = ${args.gap_index};
+          if (gapIdx >= gaps.length) return __error("Gap index " + gapIdx + " out of range (found " + gaps.length + " gaps)");
+          var gap = gaps[gapIdx];
+          var gapDuration = gap.endTicks - gap.startTicks;
+          // Use QE DOM to perform ripple delete (extract) on the gap range
+          app.enableQE();
+          var qeSeq = qe.project.getActiveSequence();
+          if (!qeSeq) return __error("No active sequence (QE)");
+          seq.setInPoint(gap.startTicks.toString());
+          seq.setOutPoint(gap.endTicks.toString());
+          qeSeq.extract();
+          return __result({
+            closed: true,
+            gapIndex: gapIdx,
+            gapDurationSeconds: __ticksToSeconds(gapDuration.toString()),
+            startSeconds: __ticksToSeconds(gap.startTicks.toString()),
+            endSeconds: __ticksToSeconds(gap.endTicks.toString())
+          });
+        `);
+                return sendCommand(script, bridgeOptions);
+            },
+        },
+        close_all_gaps: {
+            description: "Close all gaps on a track.",
+            parameters: {
+                type: "object",
+                properties: {
+                    track_type: { type: "string", description: "Track type: 'video' or 'audio'" },
+                    track_index: { type: "number", description: "Track index (0-based)" },
+                },
+                required: ["track_type", "track_index"],
+            },
+            handler: async (args) => {
+                const script = buildToolScript(`
+          var seq = app.project.activeSequence;
+          if (!seq) return __error("No active sequence");
+          var trackType = "${escapeForExtendScript(args.track_type)}";
+          var track = trackType === "video" ? seq.videoTracks[${args.track_index}] : seq.audioTracks[${args.track_index}];
+          if (!track) return __error("Track not found at index ${args.track_index}");
+          app.enableQE();
+          var qeSeq = qe.project.getActiveSequence();
+          if (!qeSeq) return __error("No active sequence (QE)");
+          var closedCount = 0;
+          // Find and close gaps from right to left to preserve positions
+          var found = true;
+          while (found) {
+            found = false;
+            var clipData = [];
+            for (var i = 0; i < track.clips.numItems; i++) {
+              var c = track.clips[i];
+              clipData.push({ startTicks: parseFloat(c.start.ticks), endTicks: parseFloat(c.end.ticks) });
+            }
+            clipData.sort(function(a, b) { return a.startTicks - b.startTicks; });
+            for (var i = clipData.length - 2; i >= 0; i--) {
+              var gapStartTicks = clipData[i].endTicks;
+              var gapEndTicks = clipData[i + 1].startTicks;
+              if (gapEndTicks > gapStartTicks + 1000) {
+                seq.setInPoint(gapStartTicks.toString());
+                seq.setOutPoint(gapEndTicks.toString());
+                qeSeq.extract();
+                closedCount++;
+                found = true;
+                break;
+              }
+            }
+          }
+          return __result({ closedGaps: closedCount, trackIndex: ${args.track_index}, trackType: trackType });
+        `);
+                return sendCommand(script, bridgeOptions);
+            },
+        },
+        ripple_delete_gap: {
+            description: "Ripple delete the gap between two time points on a track.",
+            parameters: {
+                type: "object",
+                properties: {
+                    track_type: { type: "string", description: "Track type: 'video' or 'audio'" },
+                    track_index: { type: "number", description: "Track index (0-based)" },
+                    start_time: { type: "number", description: "Start of the gap in seconds" },
+                    end_time: { type: "number", description: "End of the gap in seconds" },
+                },
+                required: ["track_type", "track_index", "start_time", "end_time"],
+            },
+            handler: async (args) => {
+                const script = buildToolScript(`
+          var seq = app.project.activeSequence;
+          if (!seq) return __error("No active sequence");
+          app.enableQE();
+          var qeSeq = qe.project.getActiveSequence();
+          if (!qeSeq) return __error("No active sequence (QE)");
+          var startTicks = __secondsToTicks(${args.start_time}).toString();
+          var endTicks = __secondsToTicks(${args.end_time}).toString();
+          seq.setInPoint(startTicks);
+          seq.setOutPoint(endTicks);
+          qeSeq.extract();
+          return __result({
+            deleted: true,
+            startSeconds: ${args.start_time},
+            endSeconds: ${args.end_time},
+            durationSeconds: ${args.end_time - args.start_time}
+          });
+        `);
+                return sendCommand(script, bridgeOptions);
+            },
+        },
+        ripple_delete_all_gaps: {
+            description: "Ripple delete all gaps on all tracks in the active sequence.",
+            parameters: {
+                type: "object",
+                properties: {},
+                required: [],
+            },
+            handler: async (_args) => {
+                const script = buildToolScript(`
+          var seq = app.project.activeSequence;
+          if (!seq) return __error("No active sequence");
+          app.enableQE();
+          var qeSeq = qe.project.getActiveSequence();
+          if (!qeSeq) return __error("No active sequence (QE)");
+          var totalClosed = 0;
+          var found = true;
+          while (found) {
+            found = false;
+            // Collect all clips from all video tracks
+            var allClipData = [];
+            for (var t = 0; t < seq.videoTracks.numTracks; t++) {
+              var track = seq.videoTracks[t];
+              for (var i = 0; i < track.clips.numItems; i++) {
+                var c = track.clips[i];
+                allClipData.push({ startTicks: parseFloat(c.start.ticks), endTicks: parseFloat(c.end.ticks) });
+              }
+            }
+            allClipData.sort(function(a, b) { return a.startTicks - b.startTicks; });
+            for (var i = allClipData.length - 2; i >= 0; i--) {
+              var gapStart = allClipData[i].endTicks;
+              var gapEnd = allClipData[i + 1].startTicks;
+              if (gapEnd > gapStart + 1000) {
+                seq.setInPoint(gapStart.toString());
+                seq.setOutPoint(gapEnd.toString());
+                qeSeq.extract();
+                totalClosed++;
+                found = true;
+                break;
+              }
+            }
+          }
+          return __result({ closedGaps: totalClosed });
+        `);
+                return sendCommand(script, bridgeOptions);
+            },
+        },
+        get_all_clips: {
+            description: "Get all clips from all tracks in the active sequence.",
+            parameters: {
+                type: "object",
+                properties: {},
+                required: [],
+            },
+            handler: async (_args) => {
+                const script = buildToolScript(`
+          var seq = app.project.activeSequence;
+          if (!seq) return __error("No active sequence");
+          var clips = __getAllClips(seq);
+          return __result({ clipCount: clips.length, clips: clips });
+        `);
+                return sendCommand(script, bridgeOptions);
+            },
+        },
+        apply_effect_to_multiple_clips: {
+            description: "Apply the same video effect to multiple clips on a track using QE DOM.",
+            parameters: {
+                type: "object",
+                properties: {
+                    track_type: { type: "string", description: "Track type: 'video' or 'audio'" },
+                    track_index: { type: "number", description: "Track index (0-based)" },
+                    clip_indices: { type: "array", description: "Array of clip indices to apply the effect to" },
+                    effect_name: { type: "string", description: "Name of the effect to apply (e.g. 'Gaussian Blur', 'Lumetri Color')" },
+                },
+                required: ["track_type", "track_index", "clip_indices", "effect_name"],
+            },
+            handler: async (args) => {
+                const clipIndicesStr = JSON.stringify(args.clip_indices);
+                const script = buildToolScript(`
+          var seq = app.project.activeSequence;
+          if (!seq) return __error("No active sequence");
+          app.enableQE();
+          var qeSeq = qe.project.getActiveSequence();
+          if (!qeSeq) return __error("No active sequence (QE)");
+          var trackType = "${escapeForExtendScript(args.track_type)}";
+          var trackIndex = ${args.track_index};
+          var effectName = "${escapeForExtendScript(args.effect_name)}";
+          var clipIndices = ${clipIndicesStr};
+
+          // Find effect in list
+          var effectList = trackType === "video" ? qe.project.getVideoEffectList() : qe.project.getAudioEffectList();
+          var effectToApply = null;
+          for (var i = 0; i < effectList.numItems; i++) {
+            if (effectList[i].name === effectName) {
+              effectToApply = effectList[i];
+              break;
+            }
+          }
+          if (!effectToApply) return __error("Effect not found: " + effectName);
+
+          var qeTrack = trackType === "video" ? qeSeq.getVideoTrackAt(trackIndex) : qeSeq.getAudioTrackAt(trackIndex);
+          if (!qeTrack) return __error("QE track not found");
+
+          var applied = 0;
+          for (var j = 0; j < clipIndices.length; j++) {
+            var qeClip = qeTrack.getItemAt(clipIndices[j]);
+            if (qeClip) {
+              if (trackType === "video") {
+                qeClip.addVideoEffect(effectToApply);
+              } else {
+                qeClip.addAudioEffect(effectToApply);
+              }
+              applied++;
+            }
+          }
+          return __result({ applied: applied, effect: effectName, trackType: trackType, trackIndex: trackIndex });
+        `);
+                return sendCommand(script, bridgeOptions);
+            },
+        },
+        remove_all_effects: {
+            description: "Remove all applied effects from a clip (keeps intrinsic Motion and Opacity).",
+            parameters: {
+                type: "object",
+                properties: {
+                    track_type: { type: "string", description: "Track type: 'video' or 'audio'" },
+                    track_index: { type: "number", description: "Track index (0-based)" },
+                    clip_index: { type: "number", description: "Clip index on the track (0-based)" },
+                },
+                required: ["track_type", "track_index", "clip_index"],
+            },
+            handler: async (args) => {
+                const script = buildToolScript(`
+          var seq = app.project.activeSequence;
+          if (!seq) return __error("No active sequence");
+          var trackType = "${escapeForExtendScript(args.track_type)}";
+          var track = trackType === "video" ? seq.videoTracks[${args.track_index}] : seq.audioTracks[${args.track_index}];
+          if (!track) return __error("Track not found");
+          var clip = track.clips[${args.clip_index}];
+          if (!clip) return __error("Clip not found at index ${args.clip_index}");
+          // Intrinsic components to preserve. matchName is locale-INDEPENDENT, so build the
+          // preserve set from __INTRINSIC matchNames first; keep English displayNames only
+          // as a secondary fallback (otherwise non-English installs delete Motion/Opacity).
+          var intrinsicMatch = [];
+          for (var key in __INTRINSIC) {
+            if (__INTRINSIC.hasOwnProperty(key)) {
+              var m = __INTRINSIC[key].match;
+              for (var mi = 0; mi < m.length; mi++) { intrinsicMatch.push(m[mi]); }
+            }
+          }
+          var preservedNames = ["Motion", "Opacity", "Volume", "Channel Volume", "Panner", "Time Remapping"];
+          var removed = [];
+          // Remove from end to start to avoid index shifting
+          for (var i = clip.components.numItems - 1; i >= 0; i--) {
+            var comp = clip.components[i];
+            var isIntrinsic = false;
+            for (var j = 0; j < intrinsicMatch.length; j++) {
+              if (comp.matchName === intrinsicMatch[j]) { isIntrinsic = true; break; }
+            }
+            if (!isIntrinsic) {
+              for (var k = 0; k < preservedNames.length; k++) {
+                if (comp.displayName === preservedNames[k]) { isIntrinsic = true; break; }
+              }
+            }
+            if (!isIntrinsic) {
+              removed.push(comp.displayName);
+              comp.remove();
+            }
+          }
+          return __result({ removed: removed, removedCount: removed.length, clipName: clip.name });
+        `);
+                return sendCommand(script, bridgeOptions);
+            },
+        },
+        apply_transition_to_all_cuts: {
+            description: "Apply a video transition to all cut points on a video track.",
+            parameters: {
+                type: "object",
+                properties: {
+                    track_index: { type: "number", description: "Video track index (0-based)" },
+                    transition_name: { type: "string", description: "Name of transition to apply (e.g. 'Cross Dissolve')" },
+                    duration: { type: "number", description: "Transition duration in seconds. Default: 1.0." },
+                },
+                required: ["track_index", "transition_name"],
+            },
+            handler: async (args) => {
+                const duration = args.duration ?? 1.0;
+                const script = buildToolScript(`
+          app.enableQE();
+          var qeSeq = qe.project.getActiveSequence();
+          if (!qeSeq) return __error("No active sequence (QE)");
+          var seq = app.project.activeSequence;
+          if (!seq) return __error("No active sequence");
+          var trackIdx = ${args.track_index};
+          var transitionName = "${escapeForExtendScript(args.transition_name)}";
+          var durationSecs = ${duration};
+          var durationTicks = __secondsToTicks(durationSecs).toString();
+
+          var transitions = qe.project.getVideoTransitionList();
+          var transitionQE = null;
+          for (var i = 0; i < transitions.numItems; i++) {
+            if (transitions[i].name === transitionName) {
+              transitionQE = transitions[i];
+              break;
+            }
+          }
+          if (!transitionQE) return __error("Transition not found: " + transitionName);
+
+          var track = seq.videoTracks[trackIdx];
+          if (!track) return __error("Video track not found at index " + trackIdx);
+          var qeTrack = qeSeq.getVideoTrackAt(trackIdx);
+          if (!qeTrack) return __error("QE track not found");
+
+          var count = 0;
+          for (var c = 0; c < track.clips.numItems - 1; c++) {
+            var cutTicks = track.clips[c].end.ticks;
+            try {
+              qeTrack.addTransition(transitionQE, true, cutTicks, durationTicks, "0", false);
+              count++;
+            } catch(e) {}
+          }
+          return __result({
+            added: count,
+            transition: transitionName,
+            trackIndex: trackIdx,
+            durationSeconds: durationSecs
+          });
+        `);
+                return sendCommand(script, bridgeOptions);
+            },
+        },
+        delete_all_clips_between: {
+            description: "Delete all clips on a track between two time points.",
+            parameters: {
+                type: "object",
+                properties: {
+                    track_type: { type: "string", description: "Track type: 'video' or 'audio'" },
+                    track_index: { type: "number", description: "Track index (0-based)" },
+                    start_seconds: { type: "number", description: "Start time in seconds" },
+                    end_seconds: { type: "number", description: "End time in seconds" },
+                },
+                required: ["track_type", "track_index", "start_seconds", "end_seconds"],
+            },
+            handler: async (args) => {
+                const script = buildToolScript(`
+          var seq = app.project.activeSequence;
+          if (!seq) return __error("No active sequence");
+          var trackType = "${escapeForExtendScript(args.track_type)}";
+          var track = trackType === "video" ? seq.videoTracks[${args.track_index}] : seq.audioTracks[${args.track_index}];
+          if (!track) return __error("Track not found at index ${args.track_index}");
+          var startTicks = __secondsToTicks(${args.start_seconds});
+          var endTicks = __secondsToTicks(${args.end_seconds});
+          var toRemove = [];
+          for (var i = 0; i < track.clips.numItems; i++) {
+            var c = track.clips[i];
+            var clipStart = parseFloat(c.start.ticks);
+            var clipEnd = parseFloat(c.end.ticks);
+            if (clipStart >= startTicks && clipEnd <= endTicks) {
+              toRemove.push(i);
+            }
+          }
+          var removed = [];
+          // Remove from end to preserve indices
+          for (var j = toRemove.length - 1; j >= 0; j--) {
+            var clip = track.clips[toRemove[j]];
+            removed.push(clip.name);
+            clip.remove(false, false);
+          }
+          return __result({
+            removed: removed,
+            removedCount: removed.length,
+            startSeconds: ${args.start_seconds},
+            endSeconds: ${args.end_seconds}
+          });
+        `);
+                return sendCommand(script, bridgeOptions);
+            },
+        },
+    };
+}
+//# sourceMappingURL=track-management.js.map