premiere-cli 0.2.0__py3-none-any.whl

premiere_cli/panel/host/commands/remove-keyframe.jsx

@@ -0,0 +1,192 @@
+// Command: remove-keyframe → ppb_removeKeyframe
+// Loaded lazily by ppb_dispatch (host/index.jsx) on first use, into the
+// same global ExtendScript context — shared helpers (findSequenceByName,
+// findClipComponent, findComponentProperty, timeValueToSeconds,
+// keyTimeToSeconds, tryTimeForms, getSequenceFps, ...) are already defined
+// there.
+//
+// Standard-DOM mutation. Ported from leancoderkavy's premiere-pro-mcp
+// `remove_keyframe` tool (keyframes.ts), addressed here by
+// trackType/trackIndex/clipIndex + componentName/propertyName. `seconds`
+// is clip-relative, offset by clip.start to sequence time. Tolerance is
+// fixed at HALF A FRAME (0.5 / sequence fps) either side of the requested
+// time, per the task spec — this is the cleanup path for add-keyframe
+// mistakes (undo is non-functional on this build), so it first tries to
+// locate an EXISTING key within tolerance via getKeys() (removing that
+// exact key object, most likely to succeed), falling back to constructing
+// a fresh time argument at the requested position via tryTimeForms() if no
+// existing key matched or getKeys() itself is unavailable. Verified via a
+// getKeys() COUNT drop, not by confirming which key vanished.
+function ppb_removeKeyframe(argsJson) {
+  try {
+    var args;
+    try {
+      args = JSON.parse(argsJson);
+    } catch (e) {
+      return JSON.stringify({ ok: false, error: "invalid args JSON: " + e.toString() });
+    }
+
+    if (args.trackType !== "video" && args.trackType !== "audio") {
+      return JSON.stringify({ ok: false, error: "trackType must be \"video\" or \"audio\"" });
+    }
+    if (typeof args.trackIndex !== "number" || args.trackIndex < 0 || Math.floor(args.trackIndex) !== args.trackIndex) {
+      return JSON.stringify({ ok: false, error: "trackIndex must be a non-negative integer" });
+    }
+    if (typeof args.clipIndex !== "number" || args.clipIndex < 0 || Math.floor(args.clipIndex) !== args.clipIndex) {
+      return JSON.stringify({ ok: false, error: "clipIndex must be a non-negative integer" });
+    }
+    if (typeof args.componentName !== "string" || !args.componentName) {
+      return JSON.stringify({ ok: false, error: "componentName is required" });
+    }
+    if (typeof args.propertyName !== "string" || !args.propertyName) {
+      return JSON.stringify({ ok: false, error: "propertyName is required" });
+    }
+    if (typeof args.seconds !== "number") {
+      return JSON.stringify({ ok: false, error: "seconds must be a number (clip-relative)" });
+    }
+
+    if (!app.project) {
+      return JSON.stringify({ ok: false, error: "no project open" });
+    }
+
+    var seq = null;
+    if (args.sequenceName && typeof args.sequenceName === "string") {
+      seq = findSequenceByName(args.sequenceName);
+      if (!seq) {
+        return JSON.stringify({ ok: false, error: "no sequence named \"" + args.sequenceName + "\" is open" });
+      }
+    } else {
+      seq = app.project.activeSequence;
+      if (!seq) {
+        return JSON.stringify({ ok: false, error: "no active sequence, and no sequenceName given" });
+      }
+    }
+
+    var trackCollection = args.trackType === "video" ? seq.videoTracks : seq.audioTracks;
+    var numTracks = trackCollection.numTracks;
+    if (args.trackIndex >= numTracks) {
+      return JSON.stringify({
+        ok: false,
+        error: "trackIndex " + args.trackIndex + " is out of range — sequence has " + numTracks + " " + args.trackType + " track(s)"
+      });
+    }
+
+    var track = trackCollection[args.trackIndex];
+    var numClips = track.clips.numItems;
+    if (args.clipIndex >= numClips) {
+      return JSON.stringify({
+        ok: false,
+        error: "clipIndex " + args.clipIndex + " is out of range — track " + args.trackIndex + " has " + numClips + " clip(s)"
+      });
+    }
+
+    var clip = track.clips[args.clipIndex];
+    var clipName = null;
+    try { clipName = clip.name; } catch (e) { clipName = null; }
+
+    var clipStartSeconds = 0;
+    try { clipStartSeconds = timeValueToSeconds(clip.start) || 0; } catch (e) { clipStartSeconds = 0; }
+
+    var comp = findClipComponent(clip, [args.componentName], [args.componentName]);
+    if (!comp) {
+      return JSON.stringify({
+        ok: false,
+        error: "component \"" + args.componentName + "\" not found on clip (matched against matchName and displayName)"
+      });
+    }
+    var compDisplayName = null;
+    try { compDisplayName = comp.displayName; } catch (e) { compDisplayName = null; }
+
+    var prop = findComponentProperty(comp, [args.propertyName]);
+    if (!prop) {
+      return JSON.stringify({
+        ok: false,
+        error: "property \"" + args.propertyName + "\" not found on component \"" + compDisplayName + "\""
+      });
+    }
+
+    var fps = 30;
+    try { fps = getSequenceFps(seq) || 30; } catch (e) { fps = 30; }
+    var toleranceSeconds = 0.5 / fps;
+
+    var sequenceSeconds = clipStartSeconds + args.seconds;
+
+    var keyCountBefore = 0;
+    var rawKeys = null;
+    try {
+      rawKeys = prop.getKeys();
+      keyCountBefore = rawKeys ? rawKeys.length : 0;
+    } catch (e) {
+      keyCountBefore = null;
+    }
+
+    var matchedKey = null;
+    var matchedSeconds = null;
+    if (rawKeys) {
+      for (var i = 0; i < rawKeys.length; i++) {
+        var ks = null;
+        try { ks = keyTimeToSeconds(rawKeys[i]); } catch (e1) { ks = null; }
+        if (ks !== null && Math.abs(ks - sequenceSeconds) <= toleranceSeconds) {
+          matchedKey = rawKeys[i];
+          matchedSeconds = ks;
+          break;
+        }
+      }
+    }
+
+    var removeAttempts = [];
+    var removed = false;
+
+    if (matchedKey !== null) {
+      try {
+        prop.removeKey(matchedKey);
+        removeAttempts.push({ form: "existingKeyObject", success: true });
+        removed = true;
+      } catch (e2) {
+        removeAttempts.push({ form: "existingKeyObject", success: false, error: e2.toString() });
+      }
+    }
+
+    if (!removed) {
+      var tf = tryTimeForms(sequenceSeconds, function (t) {
+        prop.removeKey(t);
+      });
+      removeAttempts = removeAttempts.concat(tf.attempts);
+      removed = tf.success;
+    }
+
+    var keyCountAfter = 0;
+    try {
+      var keysAfter = prop.getKeys();
+      keyCountAfter = keysAfter ? keysAfter.length : 0;
+    } catch (e3) {
+      keyCountAfter = null;
+    }
+
+    var verified = (keyCountBefore !== null && keyCountAfter !== null && keyCountAfter === keyCountBefore - 1);
+
+    return JSON.stringify({
+      ok: true,
+      result: {
+        sequenceName: seq.name,
+        trackType: args.trackType,
+        trackIndex: args.trackIndex,
+        clipIndex: args.clipIndex,
+        clipName: clipName,
+        componentName: compDisplayName,
+        propertyName: args.propertyName,
+        seconds: args.seconds,
+        sequenceSeconds: sequenceSeconds,
+        toleranceSeconds: toleranceSeconds,
+        matchedExistingKey: matchedKey !== null,
+        matchedSeconds: matchedSeconds,
+        removeAttempts: removeAttempts,
+        keyCountBefore: keyCountBefore,
+        keyCountAfter: keyCountAfter,
+        verified: verified
+      }
+    });
+  } catch (e) {
+    return JSON.stringify({ ok: false, error: e.toString() });
+  }
+}

premiere_cli/panel/host/commands/remove-selected-clips.jsx

@@ -0,0 +1,126 @@
+// Command: remove-selected-clips → ppb_removeSelectedClips
+// Loaded lazily by ppb_dispatch (host/index.jsx) on first use, into the
+// same global ExtendScript context — shared helpers (findSequenceByName,
+// serializeTrackItem, ...) are already defined there.
+//
+// Ported from leancoderkavy/premiere-pro-mcp's track-targeting.ts
+// remove_selected_clips. Removes every currently-selected clip (video+
+// audio) via clip.remove(rippleBool, /*alignToVideo*/true). Selected
+// clips are collected BACKWARDS per track (highest clipIndex first) so
+// that removing one clip never invalidates the still-pending indices of
+// clips before it on the same track — a ripple=true removal shifts every
+// later clip on that track.
+//
+// Destructive: removed clips cannot be restored (undo is non-functional
+// on this build per README.md) — verify on a duplicate/throwaway
+// sequence before running against real footage.
+//
+// Verification: total clip count across all tracks, before/after, plus a
+// per-clip removed/failed breakdown (never trusting remove()'s own return
+// value — same rule as every other mutation command in this panel).
+function ppb_countAllClips(seq) {
+  var total = 0;
+  try {
+    for (var v = 0; v < seq.videoTracks.numTracks; v++) {
+      total += seq.videoTracks[v].clips.numItems;
+    }
+  } catch (e) {
+    // best-effort
+  }
+  try {
+    for (var a = 0; a < seq.audioTracks.numTracks; a++) {
+      total += seq.audioTracks[a].clips.numItems;
+    }
+  } catch (e) {
+    // best-effort
+  }
+  return total;
+}
+
+function ppb_removeSelectedClips(argsJson) {
+  try {
+    var args;
+    try {
+      args = JSON.parse(argsJson);
+    } catch (e) {
+      return JSON.stringify({ ok: false, error: "invalid args JSON: " + e.toString() });
+    }
+
+    if (!app.project) {
+      return JSON.stringify({ ok: false, error: "no project open" });
+    }
+
+    var seq = null;
+    if (args.sequenceName && typeof args.sequenceName === "string") {
+      seq = findSequenceByName(args.sequenceName);
+      if (!seq) {
+        return JSON.stringify({ ok: false, error: "no sequence named \"" + args.sequenceName + "\" is open" });
+      }
+    } else {
+      seq = app.project.activeSequence;
+      if (!seq) {
+        return JSON.stringify({ ok: false, error: "no active sequence, and no sequenceName given" });
+      }
+    }
+
+    var ripple = args.ripple === true;
+
+    var toRemove = [];
+    function collectSelectedBackwards(tracks, trackType) {
+      for (var t = 0; t < tracks.numTracks; t++) {
+        for (var c = tracks[t].clips.numItems - 1; c >= 0; c--) {
+          var clip = tracks[t].clips[c];
+          var isSel = false;
+          try { isSel = clip.isSelected(); } catch (e) { isSel = false; }
+          if (isSel) {
+            var name = null;
+            try { name = clip.name; } catch (e2) { name = null; }
+            toRemove.push({ clip: clip, trackType: trackType, trackIndex: t, clipIndex: c, name: name });
+          }
+        }
+      }
+    }
+    collectSelectedBackwards(seq.videoTracks, "video");
+    collectSelectedBackwards(seq.audioTracks, "audio");
+
+    var countBefore = ppb_countAllClips(seq);
+
+    var results = [];
+    var removedCount = 0;
+    for (var i = 0; i < toRemove.length; i++) {
+      var entry = toRemove[i];
+      var removeError = null;
+      try {
+        entry.clip.remove(ripple, true);
+        removedCount++;
+      } catch (e) {
+        removeError = e.toString();
+      }
+      results.push({
+        trackType: entry.trackType,
+        trackIndex: entry.trackIndex,
+        clipIndex: entry.clipIndex,
+        name: entry.name,
+        error: removeError
+      });
+    }
+
+    var countAfter = ppb_countAllClips(seq);
+
+    return JSON.stringify({
+      ok: true,
+      result: {
+        sequenceName: seq.name,
+        ripple: ripple,
+        selectedCount: toRemove.length,
+        removedCount: removedCount,
+        countBefore: countBefore,
+        countAfter: countAfter,
+        verified: countAfter === countBefore - removedCount,
+        results: results
+      }
+    });
+  } catch (e) {
+    return JSON.stringify({ ok: false, error: e.toString() });
+  }
+}

premiere_cli/panel/host/commands/remove-track-intervals.jsx

@@ -0,0 +1,254 @@
+// Command: remove-track-intervals → ppb_removeTrackIntervals
+// Loaded lazily by ppb_dispatch (host/index.jsx) on first use, into the
+// same global ExtendScript context — shared helpers (ensureQEEnabled,
+// findSequenceByName, getSequenceFps, timecodeToSeconds, ...) are already
+// defined there.
+//
+// Ripple-deletes a list of time intervals from an audio track (and,
+// optionally, from one or more linked video tracks so they stay in
+// sync), via the QE DOM's razor() + a rippleDelete()/remove() fallback
+// whose success is judged by an actual numItems drop, not either call's
+// return value (both are unreliable in practice on this Premiere
+// version). Adapted from a proven implementation in a sibling project.
+//
+// QE DOM operates on qe.project.getActiveSequence() only — whichever
+// sequence tab is frontmost — so this command makes the resolved
+// sequence the active one first (app.project.activeSequence = seq)
+// rather than erroring if it isn't already.
+
+function toQeTimecode(timecode) {
+  // remove_pauses.py's frames_to_timecode() emits total elapsed minutes with
+  // no 60-minute cap (e.g. 75 minutes in prints as "75:03:12"), so MM here
+  // can exceed 59 for any sequence over an hour. QE razor() wants a genuine
+  // "HH:MM:SS:FF" with minutes in [0,59], so carry the excess into hours
+  // rather than assuming MM is always sub-hour.
+  var parts = timecode.split(":");
+  var totalMinutes = parseInt(parts[0], 10);
+  var seconds = parts[1];
+  var frames = parts[2];
+  var hours = Math.floor(totalMinutes / 60);
+  var minutes = totalMinutes % 60;
+  function pad2(n) {
+    return (n < 10 ? "0" : "") + n;
+  }
+  return pad2(hours) + ":" + pad2(minutes) + ":" + seconds + ":" + frames;
+}
+
+function findAndRemoveInRange(qeTrack, startSeconds, endSeconds, tolerance, warnings, trackLabel) {
+  var matches = [];
+  for (var k = 0; k < qeTrack.numItems; k++) {
+    var item = qeTrack.getItemAt(k);
+    // QE track items include "Empty" gap placeholders alongside real
+    // "Clip" items (confirmed earlier this session, see QE_DOM_NOTES.md).
+    // Razoring both boundaries of a pause can leave an Empty item bounded
+    // by the same tolerance window as the real Clip we actually want to
+    // remove — attempting to remove an Empty item is a harmless no-op
+    // (there's nothing there), but it was previously misreported as a
+    // removal failure. Skip non-Clip items so warnings only fire for
+    // genuine failures.
+    if (item.type !== "Clip") {
+      continue;
+    }
+    var itemStart = Number(item.start.ticks) / TICKS_PER_SECOND;
+    var itemEnd = Number(item.end.ticks) / TICKS_PER_SECOND;
+    if (itemStart > startSeconds - tolerance && itemEnd < endSeconds + tolerance) {
+      matches.push(item);
+    }
+  }
+
+  var removed = 0;
+  for (var m = 0; m < matches.length; m++) {
+    var target = matches[m];
+    var succeeded = false;
+    var itemCountBefore = qeTrack.numItems;
+
+    if (typeof target.rippleDelete === "function") {
+      try {
+        target.rippleDelete();
+      } catch (e) {
+        // fall through to the numItems check below regardless
+      }
+      succeeded = qeTrack.numItems < itemCountBefore;
+    }
+
+    if (!succeeded && typeof target.remove === "function") {
+      // QE clip.remove()'s two boolean params are undocumented (roughly
+      // ripple/alignToVideo-shaped, per Premiere's standard-DOM equivalent) —
+      // try plausible combinations and judge success by numItems, not by
+      // assuming what either flag means.
+      var attempts = [[true, false], [true, true], [false, true], [false, false]];
+      for (var a = 0; a < attempts.length && !succeeded; a++) {
+        var countBeforeAttempt = qeTrack.numItems;
+        try {
+          target.remove(attempts[a][0], attempts[a][1]);
+        } catch (e) {
+          // fall through to the numItems check below regardless
+        }
+        succeeded = qeTrack.numItems < countBeforeAttempt;
+      }
+    }
+
+    if (succeeded) {
+      removed++;
+    }
+  }
+
+  if (removed < matches.length) {
+    warnings.push(
+      trackLabel + ": " + (matches.length - removed) + " of " + matches.length +
+      " segment(s) in range could not be removed (rippleDelete/remove all reported no change)"
+    );
+  }
+
+  return removed;
+}
+
+function ppb_removeTrackIntervals(argsJson) {
+  try {
+    var args;
+    try {
+      args = JSON.parse(argsJson);
+    } catch (e) {
+      return JSON.stringify({ ok: false, error: "invalid args JSON: " + e.toString() });
+    }
+
+    if (typeof args.audioTrackIndex !== "number" || args.audioTrackIndex < 0 || Math.floor(args.audioTrackIndex) !== args.audioTrackIndex) {
+      return JSON.stringify({ ok: false, error: "audioTrackIndex must be a non-negative integer" });
+    }
+    var videoTrackIndices = args.videoTrackIndices || [];
+    if (!(videoTrackIndices instanceof Array)) {
+      return JSON.stringify({ ok: false, error: "videoTrackIndices must be an array" });
+    }
+    for (var vi = 0; vi < videoTrackIndices.length; vi++) {
+      var vIdx = videoTrackIndices[vi];
+      if (typeof vIdx !== "number" || vIdx < 0 || Math.floor(vIdx) !== vIdx) {
+        return JSON.stringify({ ok: false, error: "videoTrackIndices must all be non-negative integers" });
+      }
+    }
+    if (!(args.intervals instanceof Array) || args.intervals.length === 0) {
+      return JSON.stringify({ ok: false, error: "intervals must be a non-empty array" });
+    }
+    var timecodeRe = /^\d{2,3}:\d{2}:\d{2}$/;
+    for (var ii = 0; ii < args.intervals.length; ii++) {
+      var iv = args.intervals[ii];
+      if (!iv || typeof iv.start !== "string" || typeof iv.end !== "string" ||
+          !timecodeRe.test(iv.start) || !timecodeRe.test(iv.end)) {
+        return JSON.stringify({ ok: false, error: "each interval must have \"start\"/\"end\" as \"MM:SS:FF\" strings (index " + ii + ")" });
+      }
+    }
+
+    if (!app.project) {
+      return JSON.stringify({ ok: false, error: "no project open" });
+    }
+
+    var seq = null;
+    if (args.sequenceName && typeof args.sequenceName === "string") {
+      seq = findSequenceByName(args.sequenceName);
+      if (!seq) {
+        return JSON.stringify({ ok: false, error: "no sequence named \"" + args.sequenceName + "\" is open" });
+      }
+    } else {
+      seq = app.project.activeSequence;
+      if (!seq) {
+        return JSON.stringify({ ok: false, error: "no active sequence, and no sequenceName given" });
+      }
+    }
+
+    // QE DOM only ever operates on the active sequence tab — switch to it
+    // rather than erroring if the resolved sequence isn't already active.
+    if (app.project.activeSequence !== seq) {
+      app.project.activeSequence = seq;
+    }
+
+    try {
+      ensureQEEnabled();
+    } catch (e) {
+      return JSON.stringify({ ok: false, error: "app.enableQE() failed: " + e.toString() });
+    }
+    if (typeof qe === "undefined" || !qe.project) {
+      return JSON.stringify({ ok: false, error: "QE DOM not available after enableQE()" });
+    }
+    var qeSequence = qe.project.getActiveSequence();
+    if (!qeSequence) {
+      return JSON.stringify({ ok: false, error: "qe.project.getActiveSequence() returned nothing after activating the sequence" });
+    }
+
+    if (args.audioTrackIndex >= qeSequence.numAudioTracks) {
+      return JSON.stringify({
+        ok: false,
+        error: "audioTrackIndex " + args.audioTrackIndex + " is out of range (sequence \"" + seq.name + "\" has " + qeSequence.numAudioTracks + " audio track(s))"
+      });
+    }
+    for (var vc = 0; vc < videoTrackIndices.length; vc++) {
+      if (videoTrackIndices[vc] >= qeSequence.numVideoTracks) {
+        return JSON.stringify({
+          ok: false,
+          error: "videoTrackIndices[" + vc + "]=" + videoTrackIndices[vc] + " is out of range (sequence \"" + seq.name + "\" has " + qeSequence.numVideoTracks + " video track(s))"
+        });
+      }
+    }
+
+    var fps = getSequenceFps(seq);
+
+    var parsedIntervals = [];
+    for (var pi = 0; pi < args.intervals.length; pi++) {
+      var rawInterval = args.intervals[pi];
+      var startSeconds = timecodeToSeconds(rawInterval.start, fps);
+      var endSeconds = timecodeToSeconds(rawInterval.end, fps);
+      if (endSeconds <= startSeconds) {
+        return JSON.stringify({ ok: false, error: "interval " + pi + " (\"" + rawInterval.start + "\" - \"" + rawInterval.end + "\") is empty or backwards" });
+      }
+      parsedIntervals.push({ start: rawInterval.start, end: rawInterval.end, startSeconds: startSeconds, endSeconds: endSeconds });
+    }
+    parsedIntervals.sort(function (a, b) { return a.startSeconds - b.startSeconds; });
+    for (var oi = 1; oi < parsedIntervals.length; oi++) {
+      if (parsedIntervals[oi].startSeconds < parsedIntervals[oi - 1].endSeconds) {
+        return JSON.stringify({
+          ok: false,
+          error: "intervals overlap (\"" + parsedIntervals[oi - 1].start + "\" - \"" + parsedIntervals[oi - 1].end +
+            "\" and \"" + parsedIntervals[oi].start + "\" - \"" + parsedIntervals[oi].end + "\")"
+        });
+      }
+    }
+
+    var tolerance = 0.5 / fps;
+    var warnings = [];
+    var totalSegmentsRemoved = 0;
+
+    // Process last-to-first: applying a cut ripples everything after it,
+    // so earlier (not-yet-processed) intervals' absolute positions stay
+    // valid until their own turn comes.
+    for (var idx = parsedIntervals.length - 1; idx >= 0; idx--) {
+      var interval = parsedIntervals[idx];
+
+      qeSequence.razor(toQeTimecode(interval.start));
+      qeSequence.razor(toQeTimecode(interval.end));
+
+      var audioTrack = qeSequence.getAudioTrackAt(args.audioTrackIndex);
+      totalSegmentsRemoved += findAndRemoveInRange(
+        audioTrack, interval.startSeconds, interval.endSeconds, tolerance, warnings, "Audio " + (args.audioTrackIndex + 1)
+      );
+
+      for (var vt = 0; vt < videoTrackIndices.length; vt++) {
+        var videoTrack = qeSequence.getVideoTrackAt(videoTrackIndices[vt]);
+        totalSegmentsRemoved += findAndRemoveInRange(
+          videoTrack, interval.startSeconds, interval.endSeconds, tolerance, warnings, "Video " + (videoTrackIndices[vt] + 1)
+        );
+      }
+    }
+
+    return JSON.stringify({
+      ok: true,
+      result: {
+        sequenceName: seq.name,
+        audioTrackIndex: args.audioTrackIndex,
+        videoTrackIndices: videoTrackIndices,
+        intervalsApplied: parsedIntervals.length,
+        totalSegmentsRemoved: totalSegmentsRemoved,
+        warnings: warnings
+      }
+    });
+  } catch (e) {
+    return JSON.stringify({ ok: false, error: e.toString() });
+  }
+}