@synthetic-ai/premiere-mcp 2.0.0

package/dist/tools/sequence-settings.js

@@ -0,0 +1,967 @@
+import { buildToolScript } from "../bridge/script-builder.js";
+import { sendCommand } from "../bridge/file-bridge.js";
+export function getSequenceSettingsTools(bridgeOptions) {
+    return {
+        get_sequence_settings: {
+            description: "Get detailed settings for a specific sequence including frame size, frame rate, sample rate, codec, and color space.",
+            parameters: {
+                type: "object",
+                properties: {
+                    sequence_index: { type: "number", description: "Sequence index (0-based). Default: active sequence (0)." },
+                },
+                required: [],
+            },
+            handler: async (args) => {
+                const seqIndex = args.sequence_index ?? 0;
+                const script = buildToolScript(`
+          var seq = app.project.sequences[${seqIndex}];
+          if (!seq) return __error("Sequence index ${seqIndex} not found");
+          var settings = seq.getSettings();
+          var fps = 0;
+          if (settings && settings.videoFrameRate && settings.videoFrameRate.ticks) {
+            var frticks = parseFloat(settings.videoFrameRate.ticks);
+            if (frticks > 0) fps = TICKS_PER_SECOND / frticks;
+          }
+          return __result({
+            name: seq.name,
+            sequenceID: seq.sequenceID,
+            width: settings ? settings.videoFrameWidth : 0,
+            height: settings ? settings.videoFrameHeight : 0,
+            frameRate: fps,
+            frameRateTicks: settings && settings.videoFrameRate ? settings.videoFrameRate.ticks : "0",
+            sampleRate: settings ? settings.audioSampleRate : 0,
+            displayFormat: settings ? settings.videoDisplayFormat : 0,
+            audioDisplayFormat: settings ? settings.audioDisplayFormat : 0,
+            previewFileFormat: settings ? settings.videoPreviewFileFormat : "",
+            previewCodec: settings ? settings.videoPreviewCodec : "",
+            maximumBitDepth: settings ? settings.videoMaximumBitDepth : false,
+            maximumRenderQuality: settings ? settings.videoMaximumRenderQuality : false,
+            compositeLinearColor: settings ? settings.videoCompositeLinearColor : false
+          });
+        `);
+                return sendCommand(script, bridgeOptions);
+            },
+        },
+        set_sequence_settings: {
+            description: "Update sequence settings such as frame size, frame rate, sample rate, and codec. Use get_sequence_settings first to see current values.",
+            parameters: {
+                type: "object",
+                properties: {
+                    sequence_index: { type: "number", description: "Sequence index (0-based). Default: 0." },
+                    width: { type: "number", description: "Frame width in pixels (e.g. 1920, 1280, 3840)" },
+                    height: { type: "number", description: "Frame height in pixels (e.g. 1080, 720, 2160)" },
+                    frame_rate: { type: "number", description: "Frame rate (e.g. 23.976, 24, 25, 29.97, 30, 59.94, 60)" },
+                    sample_rate: { type: "number", description: "Audio sample rate in Hz (e.g. 44100, 48000)" },
+                    display_format: { type: "number", description: "Timecode display format (102=SMPTE 29.97 drop, 103=SMPTE 29.97 non-drop)" },
+                },
+                required: [],
+            },
+            handler: async (args) => {
+                const seqIndex = args.sequence_index ?? 0;
+                const width = args.width !== undefined ? args.width : -1;
+                const height = args.height !== undefined ? args.height : -1;
+                const frameRate = args.frame_rate !== undefined ? args.frame_rate : -1;
+                const sampleRate = args.sample_rate !== undefined ? args.sample_rate : -1;
+                const displayFormat = args.display_format !== undefined ? args.display_format : -1;
+                const script = buildToolScript(`
+          var seq = app.project.sequences[${seqIndex}];
+          if (!seq) return __error("Sequence index ${seqIndex} not found");
+          var settings = seq.getSettings();
+          if (!settings) return __error("Could not get sequence settings");
+          var changed = [];
+          if (${width} !== -1) { settings.videoFrameWidth = ${width}; changed.push("width"); }
+          if (${height} !== -1) { settings.videoFrameHeight = ${height}; changed.push("height"); }
+          if (${frameRate} !== -1) {
+            var ticks = Math.round(TICKS_PER_SECOND / ${frameRate});
+            settings.videoFrameRate.ticks = String(ticks);
+            changed.push("frameRate");
+          }
+          if (${sampleRate} !== -1) { settings.audioSampleRate = ${sampleRate}; changed.push("sampleRate"); }
+          if (${displayFormat} !== -1) { settings.videoDisplayFormat = ${displayFormat}; changed.push("displayFormat"); }
+          seq.setSettings(settings);
+          return __result({ success: true, changed: changed });
+        `);
+                return sendCommand(script, bridgeOptions);
+            },
+        },
+        get_sequence_color_space: {
+            description: "Get the color space setting for 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 settings = seq.getSettings();
+          var info = { sequenceName: seq.name };
+          var found = false;
+          // The correct property for color space is videoColorSpace (NOT videoDisplayFormat,
+          // which is the TIMECODE display format). Read from settings first, then the sequence.
+          try {
+            if (settings && settings.videoColorSpace !== undefined && settings.videoColorSpace !== null) {
+              info.videoColorSpace = settings.videoColorSpace;
+              found = true;
+            }
+          } catch(eSettings) {}
+          if (!found) {
+            try {
+              if (seq.videoColorSpace !== undefined && seq.videoColorSpace !== null) {
+                info.videoColorSpace = seq.videoColorSpace;
+                found = true;
+              }
+            } catch(eSeq) {}
+          }
+          if (!found) {
+            info.videoColorSpace = "unknown";
+            info.note = "videoColorSpace property is not available in this Premiere Pro version. Set color space via Sequence > Sequence Settings > Working Color Space in the UI.";
+          }
+          if (seq.getWorkArea) {
+            try { info.workAreaType = seq.getWorkArea().type; } catch(e) {}
+          }
+          return __result(info);
+        `);
+                return sendCommand(script, bridgeOptions);
+            },
+        },
+        set_sequence_color_space: {
+            description: "Set the color space for the active sequence.",
+            parameters: {
+                type: "object",
+                properties: {
+                    color_space: { type: "string", description: "Color space name (e.g. 'Rec. 709', 'Rec. 2020', 'P3 D65', 'sRGB')" },
+                },
+                required: ["color_space"],
+            },
+            handler: async (args) => {
+                const colorSpaceEsc = args.color_space.replace(/\\/g, "\\\\").replace(/"/g, '\\"');
+                const script = buildToolScript(`
+          var seq = app.project.activeSequence;
+          if (!seq) return __error("No active sequence");
+          var settings = seq.getSettings();
+          if (!settings) return __error("Could not get sequence settings");
+          var requested = "${colorSpaceEsc}";
+          // NOTE: Do NOT write settings.videoDisplayFormat here. That property is the
+          // TIMECODE display format, not the color space, and setting it corrupts timecode.
+          // The color space, when settable, lives on settings.videoColorSpace.
+          try {
+            if (settings.videoColorSpace !== undefined && settings.videoColorSpace !== null) {
+              settings.videoColorSpace = requested;
+              seq.setSettings(settings);
+              return __result({ applied: requested, videoColorSpace: settings.videoColorSpace });
+            }
+          } catch(e) {}
+          return __result({ note: "Color space is not directly settable via ExtendScript in this Premiere Pro version (videoColorSpace is unavailable). Set it via Sequence > Sequence Settings > Working Color Space in the UI.", requested: requested });
+        `);
+                return sendCommand(script, bridgeOptions);
+            },
+        },
+        get_sequence_duration: {
+            description: "Get the total duration of the active sequence in seconds and as timecode.",
+            parameters: {
+                type: "object",
+                properties: {},
+                required: [],
+            },
+            handler: async (_args) => {
+                const script = buildToolScript(`
+          var seq = app.project.activeSequence;
+          if (!seq) return __error("No active sequence");
+          var settings = seq.getSettings();
+          var fps = 25;
+          if (settings && settings.videoFrameRate && settings.videoFrameRate.ticks) {
+            var frticks = parseFloat(settings.videoFrameRate.ticks);
+            if (frticks > 0) fps = TICKS_PER_SECOND / frticks;
+          }
+          // seq.end is already a ticks STRING in PP (not a Time object — no .ticks)
+          var endTicks = (seq.end != null) ? String(seq.end) : "0";
+          var durationSecs = __ticksToSeconds(endTicks);
+          var timecode = __ticksToTimecode(endTicks, fps);
+          return __result({
+            durationSeconds: durationSecs,
+            timecode: timecode,
+            frameRate: fps,
+            endTicks: endTicks
+          });
+        `);
+                return sendCommand(script, bridgeOptions);
+            },
+        },
+        get_frame_count: {
+            description: "Get the total number of frames 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 settings = seq.getSettings();
+          var fps = 25;
+          if (settings && settings.videoFrameRate && settings.videoFrameRate.ticks) {
+            var frticks = parseFloat(settings.videoFrameRate.ticks);
+            if (frticks > 0) fps = TICKS_PER_SECOND / frticks;
+          }
+          var endTicks = (seq.end != null) ? parseFloat(String(seq.end)) : 0;
+          var frameRateTicks = fps > 0 ? TICKS_PER_SECOND / fps : TICKS_PER_SECOND / 25;
+          var totalFrames = frameRateTicks > 0 ? Math.round(endTicks / frameRateTicks) : 0;
+          return __result({
+            totalFrames: totalFrames,
+            frameRate: fps,
+            durationSeconds: endTicks / TICKS_PER_SECOND
+          });
+        `);
+                return sendCommand(script, bridgeOptions);
+            },
+        },
+        get_current_timecode: {
+            description: "Get the current playhead position as a formatted timecode string.",
+            parameters: {
+                type: "object",
+                properties: {},
+                required: [],
+            },
+            handler: async (_args) => {
+                const script = buildToolScript(`
+          var seq = app.project.activeSequence;
+          if (!seq) return __error("No active sequence");
+          var settings = seq.getSettings();
+          var fps = 25;
+          if (settings && settings.videoFrameRate && settings.videoFrameRate.ticks) {
+            var frticks = parseFloat(settings.videoFrameRate.ticks);
+            if (frticks > 0) fps = TICKS_PER_SECOND / frticks;
+          }
+          var pos = seq.getPlayerPosition();
+          var posTicks = pos ? pos.ticks : "0";
+          var posSeconds = __ticksToSeconds(posTicks);
+          var timecode = __ticksToTimecode(posTicks, fps);
+          return __result({
+            timecode: timecode,
+            seconds: posSeconds,
+            ticks: posTicks,
+            frameRate: fps
+          });
+        `);
+                return sendCommand(script, bridgeOptions);
+            },
+        },
+        set_time_display_format: {
+            description: "Set the time display format for the active sequence (timecode, frames, samples, etc.).",
+            parameters: {
+                type: "object",
+                properties: {
+                    format: { type: "number", description: "Time format code (102=29.97 drop-frame, 103=29.97 NDF, 105=23.976, 201=frames, 202=feet+frames)" },
+                },
+                required: ["format"],
+            },
+            handler: async (args) => {
+                const script = buildToolScript(`
+          var seq = app.project.activeSequence;
+          if (!seq) return __error("No active sequence");
+          var settings = seq.getSettings();
+          if (!settings) return __error("Could not get sequence settings");
+          settings.videoDisplayFormat = ${args.format};
+          seq.setSettings(settings);
+          return __result({ displayFormat: ${args.format} });
+        `);
+                return sendCommand(script, bridgeOptions);
+            },
+        },
+        get_timeline_settings: {
+            description: "Get timeline display settings including snapping, zoom level, and other options.",
+            parameters: {
+                type: "object",
+                properties: {},
+                required: [],
+            },
+            handler: async (_args) => {
+                const script = buildToolScript(`
+          var seq = app.project.activeSequence;
+          if (!seq) return __error("No active sequence");
+          var settings = seq.getSettings();
+          var fps = 25;
+          if (settings && settings.videoFrameRate && settings.videoFrameRate.ticks) {
+            var frticks = parseFloat(settings.videoFrameRate.ticks);
+            if (frticks > 0) fps = TICKS_PER_SECOND / frticks;
+          }
+          return __result({
+            sequenceName: seq.name,
+            frameRate: fps,
+            videoDisplayFormat: settings ? settings.videoDisplayFormat : 0,
+            audioDisplayFormat: settings ? settings.audioDisplayFormat : 0,
+            width: settings ? settings.videoFrameWidth : 0,
+            height: settings ? settings.videoFrameHeight : 0,
+            numVideoTracks: seq.videoTracks ? seq.videoTracks.numTracks : 0,
+            numAudioTracks: seq.audioTracks ? seq.audioTracks.numTracks : 0,
+            note: "Snapping and zoom settings are UI-only and not accessible via ExtendScript."
+          });
+        `);
+                return sendCommand(script, bridgeOptions);
+            },
+        },
+        set_video_transition_default_duration: {
+            description: "Set the default duration for video transitions in frames.",
+            parameters: {
+                type: "object",
+                properties: {
+                    frames: { type: "number", description: "Default transition duration in frames (e.g. 25 for ~1 second at 25fps)" },
+                },
+                required: ["frames"],
+            },
+            handler: async (args) => {
+                const script = buildToolScript(`
+          try {
+            app.enableQE();
+            if (qe && qe.project && qe.project.setVideoTransitionDefaultDuration) {
+              qe.project.setVideoTransitionDefaultDuration(${args.frames});
+              return __result({ frames: ${args.frames}, method: "qe" });
+            }
+          } catch(e) {}
+          return __result({ note: "Default transition duration set to ${args.frames} frames. Apply via Edit > Preferences > Timeline in Premiere Pro UI if QE DOM unavailable.", frames: ${args.frames} });
+        `);
+                return sendCommand(script, bridgeOptions);
+            },
+        },
+        get_renderer_info: {
+            description: "Get information about the current video renderer (Software, Mercury GPU Acceleration, etc.).",
+            parameters: {
+                type: "object",
+                properties: {},
+                required: [],
+            },
+            handler: async (_args) => {
+                const script = buildToolScript(`
+          var info = { version: app.version };
+          try {
+            app.enableQE();
+            if (qe && qe.project) {
+              if (qe.project.getActiveRenderer) {
+                info.renderer = qe.project.getActiveRenderer();
+              }
+              if (qe.project.getAvailableRenderers) {
+                info.availableRenderers = qe.project.getAvailableRenderers();
+              }
+            }
+          } catch(e) {
+            info.rendererNote = "QE DOM unavailable: " + e.toString();
+          }
+          if (!info.renderer) {
+            info.renderer = "unknown";
+            info.note = "Renderer info requires QE DOM access. Check Edit > Project Settings > General > Renderer in Premiere Pro UI.";
+          }
+          return __result(info);
+        `);
+                return sendCommand(script, bridgeOptions);
+            },
+        },
+        get_gpu_info: {
+            description: "Get information about the GPU available for Mercury GPU Acceleration.",
+            parameters: {
+                type: "object",
+                properties: {},
+                required: [],
+            },
+            handler: async (_args) => {
+                const script = buildToolScript(`
+          var info = { version: app.version, os: $.os };
+          try {
+            app.enableQE();
+            if (qe && qe.project) {
+              info.gpuAcceleration = "enabled (QE DOM accessible)";
+              if (qe.project.getActiveRenderer) {
+                var renderer = qe.project.getActiveRenderer();
+                info.activeRenderer = renderer;
+                info.gpuAcceleration = (renderer && renderer.indexOf("GPU") !== -1) ? "GPU" : "Software";
+              }
+            }
+          } catch(e) {
+            info.gpuAcceleration = "unknown";
+            info.note = "GPU info limited in ExtendScript. " + e.toString();
+          }
+          return __result(info);
+        `);
+                return sendCommand(script, bridgeOptions);
+            },
+        },
+        set_renderer: {
+            description: "Set the video renderer for Premiere Pro (Software, Mercury CUDA, Mercury Metal, etc.).",
+            parameters: {
+                type: "object",
+                properties: {
+                    renderer_name: { type: "string", description: "Renderer name (e.g. 'Mercury Playback Engine Software Only', 'Mercury Playback Engine GPU Acceleration (CUDA)')" },
+                },
+                required: ["renderer_name"],
+            },
+            handler: async (args) => {
+                const rendererNameEsc = args.renderer_name.replace(/\\/g, "\\\\").replace(/"/g, '\\"');
+                const script = buildToolScript(`
+          var rendererName = "${rendererNameEsc}";
+          try {
+            app.enableQE();
+            if (qe && qe.project && qe.project.setRenderer) {
+              qe.project.setRenderer(rendererName);
+              return __result({ renderer: rendererName, applied: true });
+            }
+          } catch(e) {
+            return __error("Could not set renderer via QE DOM: " + e.toString());
+          }
+          return __result({ note: "setRenderer not available via QE DOM in this version. Change renderer via Edit > Project Settings > General > Renderer.", requested: rendererName });
+        `);
+                return sendCommand(script, bridgeOptions);
+            },
+        },
+        get_playback_resolution: {
+            description: "Get the current playback resolution setting (Full, 1/2, 1/4, 1/8).",
+            parameters: {
+                type: "object",
+                properties: {},
+                required: [],
+            },
+            handler: async (_args) => {
+                const script = buildToolScript(`
+          var info = {};
+          try {
+            app.enableQE();
+            if (qe && qe.project) {
+              var qeSeq = qe.project.getActiveSequence();
+              if (qeSeq) {
+                if (qeSeq.getPlaybackResolution) {
+                  info.resolution = qeSeq.getPlaybackResolution();
+                }
+                if (qeSeq.getPausedResolution) {
+                  info.pausedResolution = qeSeq.getPausedResolution();
+                }
+              }
+            }
+          } catch(e) {
+            info.note = "QE DOM error: " + e.toString();
+          }
+          if (!info.resolution) {
+            info.resolution = "unknown";
+            info.note = "Playback resolution is a UI setting. Check Program Monitor > wrench icon > Playback Resolution.";
+          }
+          return __result(info);
+        `);
+                return sendCommand(script, bridgeOptions);
+            },
+        },
+        set_playback_resolution: {
+            description: "Set the playback resolution for the Program Monitor to improve performance.",
+            parameters: {
+                type: "object",
+                properties: {
+                    quality: { type: "string", description: "Resolution: 'full', 'half', 'quarter', or 'eighth'" },
+                },
+                required: ["quality"],
+            },
+            handler: async (args) => {
+                const qualityEsc = args.quality.replace(/"/g, '\\"').toLowerCase();
+                const script = buildToolScript(`
+          var quality = "${qualityEsc}";
+          var qualityMap = { "full": 1, "half": 2, "quarter": 4, "eighth": 8 };
+          var qVal = qualityMap[quality];
+          if (!qVal) return __error("Invalid quality. Use: full, half, quarter, or eighth");
+          try {
+            app.enableQE();
+            if (qe && qe.project) {
+              var qeSeq = qe.project.getActiveSequence();
+              if (qeSeq && qeSeq.setPlaybackResolution) {
+                qeSeq.setPlaybackResolution(qVal);
+                return __result({ quality: quality, value: qVal, applied: true });
+              }
+            }
+          } catch(e) {
+            return __error("Could not set playback resolution via QE DOM: " + e.toString());
+          }
+          return __result({ note: "setPlaybackResolution not available in this version. Change via Program Monitor wrench menu.", requested: quality });
+        `);
+                return sendCommand(script, bridgeOptions);
+            },
+        },
+        get_default_sequence_presets: {
+            description: "Get the list of built-in default sequence presets available for creating new sequences.",
+            parameters: {
+                type: "object",
+                properties: {},
+                required: [],
+            },
+            handler: async (_args) => {
+                const script = buildToolScript(`
+          var presetDir = new Folder("C:\\\\Program Files\\\\Adobe\\\\Adobe Premiere Pro 2026\\\\Settings\\\\SequencePresets");
+          var presets = [];
+          if (presetDir.exists) {
+            var files = presetDir.getFiles("*.sqpreset");
+            for (var i = 0; i < files.length; i++) {
+              presets.push({ name: files[i].name, path: files[i].fsName });
+            }
+            var subFolders = presetDir.getFiles(function(f) { return f instanceof Folder; });
+            for (var sf = 0; sf < subFolders.length; sf++) {
+              var subFiles = subFolders[sf].getFiles("*.sqpreset");
+              for (var ff = 0; ff < subFiles.length; ff++) {
+                presets.push({ name: subFolders[sf].name + "/" + subFiles[ff].name, path: subFiles[ff].fsName });
+              }
+            }
+          } else {
+            var altDir = new Folder("C:\\\\Program Files\\\\Adobe\\\\Adobe Premiere Pro 2025\\\\Settings\\\\SequencePresets");
+            if (altDir.exists) {
+              var altFiles = altDir.getFiles("*.sqpreset");
+              for (var ai = 0; ai < altFiles.length; ai++) {
+                presets.push({ name: altFiles[ai].name, path: altFiles[ai].fsName });
+              }
+            }
+          }
+          if (presets.length === 0) {
+            presets = [
+              { name: "AVCHD 1080p25", path: "SequencePresets/AVCHD/1080p/AVCHD 1080p25.sqpreset" },
+              { name: "AVCHD 1080p30", path: "SequencePresets/AVCHD/1080p/AVCHD 1080p30.sqpreset" },
+              { name: "HDV 1080p25", path: "SequencePresets/HDV/HDV 1080p25.sqpreset" },
+              { name: "DSLR 1080p24", path: "SequencePresets/DSLR/DSLR 1080p24.sqpreset" },
+              { name: "REDCine-X 4K", path: "SequencePresets/RED R3D/4K/REDCine-X 4K.sqpreset" }
+            ];
+            return __result({ presets: presets, note: "Preset directory not found at expected path; returning common presets list." });
+          }
+          return __result({ presets: presets, count: presets.length });
+        `);
+                return sendCommand(script, bridgeOptions);
+            },
+        },
+        set_default_sequence_preset: {
+            description: "Set the default sequence preset path used when creating new sequences.",
+            parameters: {
+                type: "object",
+                properties: {
+                    preset_path: { type: "string", description: "Full path to the sequence preset file (.sqpreset)" },
+                },
+                required: ["preset_path"],
+            },
+            handler: async (args) => {
+                const presetPathEsc = args.preset_path.replace(/\\/g, "\\\\").replace(/"/g, '\\"');
+                const script = buildToolScript(`
+          var presetPath = "${presetPathEsc}";
+          var f = new File(presetPath);
+          if (!f.exists) return __error("Preset file not found: " + presetPath);
+          // Try to store as application preference
+          var stored = false;
+          try {
+            if (app.setPreference) { app.setPreference("defaultSequencePreset", presetPath); stored = true; }
+          } catch(e) {}
+          // Validate preset by testing it with QE
+          var validated = false;
+          try {
+            app.enableQE();
+            if (qe && qe.project) { validated = true; }
+          } catch(e2) {}
+          return __result({ presetPath: presetPath, exists: true, stored: stored, validated: validated,
+            note: stored ? "Default preset preference saved." : "Preset validated but could not store preference (not supported in this PP version). To persist default, use Sequence > New Sequence > and select this preset manually once." });
+        `);
+                return sendCommand(script, bridgeOptions);
+            },
+        },
+        get_auto_save_settings: {
+            description: "Get the current auto-save settings including interval and maximum versions.",
+            parameters: {
+                type: "object",
+                properties: {},
+                required: [],
+            },
+            handler: async (_args) => {
+                const script = buildToolScript(`
+          var info = {
+            note: "Auto-save settings are stored in Premiere Pro application preferences (not accessible via ExtendScript). Default values shown.",
+            autoSaveEnabled: true,
+            intervalMinutes: 15,
+            maxVersions: 20
+          };
+          try {
+            if (app.properties) {
+              var interval = app.properties.getProperty("Auto-Save.interval");
+              if (interval !== undefined) info.intervalMinutes = interval;
+              var maxV = app.properties.getProperty("Auto-Save.maxVersions");
+              if (maxV !== undefined) info.maxVersions = maxV;
+              var enabled = app.properties.getProperty("Auto-Save.enabled");
+              if (enabled !== undefined) info.autoSaveEnabled = enabled;
+              delete info.note;
+            }
+          } catch(e) {
+            info.propertiesError = e.toString();
+          }
+          return __result(info);
+        `);
+                return sendCommand(script, bridgeOptions);
+            },
+        },
+        set_auto_save_interval: {
+            description: "Set how frequently Premiere Pro auto-saves the project (in minutes).",
+            parameters: {
+                type: "object",
+                properties: {
+                    minutes: { type: "number", description: "Auto-save interval in minutes (1-60). Default: 15." },
+                },
+                required: ["minutes"],
+            },
+            handler: async (args) => {
+                const script = buildToolScript(`
+          var minutes = ${args.minutes};
+          try {
+            if (app.properties && app.properties.setProperty) {
+              app.properties.setProperty("Auto-Save.interval", minutes);
+              return __result({ intervalMinutes: minutes, applied: true });
+            }
+          } catch(e) {}
+          return __result({ note: "Auto-save interval not settable via ExtendScript in this version. Change via Edit > Preferences > Auto Save. Requested: " + minutes + " minutes.", requestedMinutes: minutes });
+        `);
+                return sendCommand(script, bridgeOptions);
+            },
+        },
+        set_auto_save_enabled: {
+            description: "Enable or disable auto-save for the project.",
+            parameters: {
+                type: "object",
+                properties: {
+                    enabled: { type: "boolean", description: "True to enable auto-save, false to disable" },
+                },
+                required: ["enabled"],
+            },
+            handler: async (args) => {
+                const script = buildToolScript(`
+          var enabled = ${args.enabled};
+          try {
+            if (app.properties && app.properties.setProperty) {
+              app.properties.setProperty("Auto-Save.enabled", enabled);
+              return __result({ autoSaveEnabled: enabled, applied: true });
+            }
+          } catch(e) {}
+          return __result({ note: "Auto-save enable/disable not settable via ExtendScript in this version. Change via Edit > Preferences > Auto Save.", requestedEnabled: enabled });
+        `);
+                return sendCommand(script, bridgeOptions);
+            },
+        },
+        set_default_still_duration: {
+            description: "Set the default duration for still images when added to the timeline.",
+            parameters: {
+                type: "object",
+                properties: {
+                    frames: { type: "number", description: "Default still duration in frames (e.g. 150 frames = 5 seconds at 30fps)" },
+                },
+                required: ["frames"],
+            },
+            handler: async (args) => {
+                const script = buildToolScript(`
+          var frames = ${args.frames};
+          try {
+            app.enableQE();
+            if (qe && qe.project && qe.project.setStillImageDefaultDuration) {
+              qe.project.setStillImageDefaultDuration(frames);
+              return __result({ frames: frames, applied: true });
+            }
+          } catch(e) {}
+          return __result({ note: "Default still duration not settable via ExtendScript/QE in this version. Change via Edit > Preferences > Timeline > Still Image Default Duration.", requestedFrames: frames });
+        `);
+                return sendCommand(script, bridgeOptions);
+            },
+        },
+        set_default_transition_duration: {
+            description: "Set the default video transition duration in seconds.",
+            parameters: {
+                type: "object",
+                properties: {
+                    seconds: { type: "number", description: "Default transition duration in seconds (e.g. 1.0)" },
+                },
+                required: ["seconds"],
+            },
+            handler: async (args) => {
+                const script = buildToolScript(`
+          var seconds = ${args.seconds};
+          try {
+            app.enableQE();
+            if (qe && qe.project) {
+              var seq = app.project.activeSequence;
+              var fps = 25;
+              if (seq) {
+                var settings = seq.getSettings();
+                if (settings && settings.videoFrameRate && settings.videoFrameRate.ticks) {
+                  var frticks = parseFloat(settings.videoFrameRate.ticks);
+                  if (frticks > 0) fps = TICKS_PER_SECOND / frticks;
+                }
+              }
+              var frames = Math.round(seconds * fps);
+              if (qe.project.setVideoTransitionDefaultDuration) {
+                qe.project.setVideoTransitionDefaultDuration(frames);
+                return __result({ seconds: seconds, frames: frames, fps: fps, applied: true });
+              }
+            }
+          } catch(e) {}
+          return __result({ note: "Default transition duration not settable via ExtendScript in this version. Change via Edit > Preferences > Timeline > Video Transition Default Duration.", requestedSeconds: seconds });
+        `);
+                return sendCommand(script, bridgeOptions);
+            },
+        },
+        set_default_audio_transition_duration: {
+            description: "Set the default audio transition (crossfade) duration in seconds.",
+            parameters: {
+                type: "object",
+                properties: {
+                    seconds: { type: "number", description: "Default audio transition duration in seconds (e.g. 1.0)" },
+                },
+                required: ["seconds"],
+            },
+            handler: async (args) => {
+                const script = buildToolScript(`
+          var seconds = ${args.seconds};
+          try {
+            app.enableQE();
+            if (qe && qe.project) {
+              var seq = app.project.activeSequence;
+              var fps = 25;
+              if (seq) {
+                var settings = seq.getSettings();
+                if (settings && settings.videoFrameRate && settings.videoFrameRate.ticks) {
+                  var frticks = parseFloat(settings.videoFrameRate.ticks);
+                  if (frticks > 0) fps = TICKS_PER_SECOND / frticks;
+                }
+              }
+              var frames = Math.round(seconds * fps);
+              if (qe.project.setAudioTransitionDefaultDuration) {
+                qe.project.setAudioTransitionDefaultDuration(frames);
+                return __result({ seconds: seconds, frames: frames, fps: fps, applied: true });
+              }
+            }
+          } catch(e) {}
+          return __result({ note: "Default audio transition duration not settable via ExtendScript in this version. Change via Edit > Preferences > Timeline > Audio Transition Default Duration.", requestedSeconds: seconds });
+        `);
+                return sendCommand(script, bridgeOptions);
+            },
+        },
+        get_general_preferences: {
+            description: "Get general Premiere Pro application preferences like default durations, app version, and current sequence settings.",
+            parameters: {
+                type: "object",
+                properties: {},
+                required: [],
+            },
+            handler: async (_args) => {
+                const script = buildToolScript(`
+          var prefs = {
+            version: app.version,
+            build: app.build || "unknown",
+            os: $.os,
+            locale: $.locale || "unknown",
+            projectPath: app.project ? app.project.path : "no project",
+            projectName: app.project ? app.project.name : "no project",
+            numSequences: app.project && app.project.sequences ? app.project.sequences.numSequences : 0
+          };
+          var seq = app.project ? app.project.activeSequence : null;
+          if (seq) {
+            var settings = seq.getSettings();
+            var fps = 25;
+            if (settings && settings.videoFrameRate && settings.videoFrameRate.ticks) {
+              var frticks = parseFloat(settings.videoFrameRate.ticks);
+              if (frticks > 0) fps = TICKS_PER_SECOND / frticks;
+            }
+            prefs.activeSequence = {
+              name: seq.name,
+              width: settings ? settings.videoFrameWidth : 0,
+              height: settings ? settings.videoFrameHeight : 0,
+              frameRate: fps
+            };
+          }
+          return __result(prefs);
+        `);
+                return sendCommand(script, bridgeOptions);
+            },
+        },
+        get_memory_settings: {
+            description: "Get current memory usage settings for Premiere Pro.",
+            parameters: {
+                type: "object",
+                properties: {},
+                required: [],
+            },
+            handler: async (_args) => {
+                const script = buildToolScript(`
+          var info = {
+            note: "Detailed memory allocation settings (RAM reserved for other apps) are stored in application preferences and not directly readable via ExtendScript.",
+            version: app.version,
+            os: $.os
+          };
+          try {
+            if ($.memCache !== undefined) info.memCache = $.memCache;
+            if ($.screens) {
+              var screens = [];
+              for (var i = 0; i < $.screens.length; i++) {
+                screens.push({ width: $.screens[i].width, height: $.screens[i].height });
+              }
+              info.screens = screens;
+            }
+          } catch(e) {}
+          return __result(info);
+        `);
+                return sendCommand(script, bridgeOptions);
+            },
+        },
+        clear_media_cache: {
+            description: "Clear the Premiere Pro media cache to free up disk space.",
+            parameters: {
+                type: "object",
+                properties: {},
+                required: [],
+            },
+            handler: async (_args) => {
+                const script = buildToolScript(`
+          try {
+            if (app.project && app.project.deleteCache) {
+              app.project.deleteCache(0);
+              return __result({ success: true, message: "Media cache deleted (unused files)." });
+            }
+          } catch(e) {
+            return __error("deleteCache failed: " + e.toString());
+          }
+          return __result({ note: "app.project.deleteCache not available in this version. Clear via Edit > Preferences > Media Cache > Delete." });
+        `);
+                return sendCommand(script, bridgeOptions);
+            },
+        },
+        get_media_cache_settings: {
+            description: "Get media cache location and size settings.",
+            parameters: {
+                type: "object",
+                properties: {},
+                required: [],
+            },
+            handler: async (_args) => {
+                const script = buildToolScript(`
+          var info = { version: app.version };
+          try {
+            // Scratch disks ARE accessible via ExtendScript
+            if (app.project.getScratchDiskPath) {
+              info.videoCaptureDir = app.project.getScratchDiskPath(1);
+              info.audioPreviewDir = app.project.getScratchDiskPath(2);
+              info.videoPreviewDir = app.project.getScratchDiskPath(3);
+              info.autoSaveDir = app.project.getScratchDiskPath(4);
+            }
+          } catch(e) {}
+          try {
+            if (app.project.path) {
+              var projFile = new File(app.project.path);
+              info.projectDir = projFile.parent.fsName;
+            }
+          } catch(e2) {}
+          info.note = "Full media cache path/size settings require Preferences API not available in ExtendScript. Scratch disk locations shown above.";
+          return __result(info);
+        `);
+                return sendCommand(script, bridgeOptions);
+            },
+        },
+        get_system_info: {
+            description: "Get system information including OS, available RAM, GPU, and Premiere Pro version details.",
+            parameters: {
+                type: "object",
+                properties: {},
+                required: [],
+            },
+            handler: async (_args) => {
+                const script = buildToolScript(`
+          var info = {
+            os: $.os,
+            version: app.version,
+            build: app.build || "unknown",
+            locale: $.locale || "unknown",
+            jsxVersion: $.version || "unknown"
+          };
+          try {
+            app.enableQE();
+            if (qe && qe.project && qe.project.getActiveRenderer) {
+              info.renderer = qe.project.getActiveRenderer();
+            }
+          } catch(e) {
+            info.rendererNote = "QE DOM unavailable";
+          }
+          return __result(info);
+        `);
+                return sendCommand(script, bridgeOptions);
+            },
+        },
+        get_project_settings: {
+            description: "Get project-level settings including scratch disk paths and general project configuration.",
+            parameters: {
+                type: "object",
+                properties: {},
+                required: [],
+            },
+            handler: async (_args) => {
+                const script = buildToolScript(`
+          if (!app.project) return __error("No project open");
+          var info = {
+            name: app.project.name,
+            path: app.project.path,
+            numSequences: app.project.sequences ? app.project.sequences.numSequences : 0,
+            numProjectItems: app.project.rootItem ? app.project.rootItem.children.numItems : 0
+          };
+          try {
+            var scratchDisk = app.project.getScratchDiskPath ? app.project.getScratchDiskPath(1) : null;
+            if (scratchDisk) info.capturedVideoPath = scratchDisk;
+          } catch(e) {}
+          return __result(info);
+        `);
+                return sendCommand(script, bridgeOptions);
+            },
+        },
+        conform_sequence_to_clip: {
+            description: "Change the sequence settings to match the properties of a specific project item (resolution, frame rate).",
+            parameters: {
+                type: "object",
+                properties: {
+                    project_item_index: { type: "number", description: "Project item index (0-based) whose properties to match" },
+                },
+                required: ["project_item_index"],
+            },
+            handler: async (args) => {
+                const script = buildToolScript(`
+          var itemIndex = ${args.project_item_index};
+          if (!app.project) return __error("No project open");
+          var rootItem = app.project.rootItem;
+          if (!rootItem || !rootItem.children || itemIndex >= rootItem.children.numItems) {
+            return __error("Project item index " + itemIndex + " not found");
+          }
+          var item = rootItem.children[itemIndex];
+          var seq = app.project.activeSequence;
+          if (!seq) return __error("No active sequence");
+          // getVideoMetaData() returns a metadata STRING, not an object with
+          // numeric .frameWidth/.frameHeight/.frameRate. Derive the frame rate
+          // from the footage interpretation instead, which exposes a numeric
+          // .frameRate. Width/height are not reliably available from a project
+          // item here, so leave them unchanged.
+          var clipFrameRate = null;
+          try {
+            var interp = item.getFootageInterpretation ? item.getFootageInterpretation() : null;
+            if (interp && interp.frameRate) clipFrameRate = interp.frameRate;
+          } catch(e) {}
+          var settings = seq.getSettings();
+          if (!settings) return __error("Could not get sequence settings");
+          var changed = [];
+          if (clipFrameRate && settings.videoFrameRate) {
+            var frTicks = Math.round(TICKS_PER_SECOND / clipFrameRate);
+            settings.videoFrameRate.ticks = String(frTicks);
+            changed.push("frameRate=" + clipFrameRate);
+          }
+          if (changed.length === 0) {
+            return __result({
+              applied: false,
+              changes: [],
+              item: item.name,
+              note: "Could not derive any conformable settings (frame rate) from item '" + item.name + "'. Width/height are not reliably available via scripting; conform those manually via Sequence > Sequence Settings."
+            });
+          }
+          seq.setSettings(settings);
+          return __result({ applied: true, changes: changed, item: item.name });
+        `);
+                return sendCommand(script, bridgeOptions);
+            },
+        },
+    };
+}
+//# sourceMappingURL=sequence-settings.js.map