premiere-cli 0.2.0__py3-none-any.whl

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

@@ -0,0 +1,164 @@
+// Command: remove-transition → ppb_removeTransition
+// Loaded lazily by ppb_dispatch (host/index.jsx) on first use, into the
+// same global ExtendScript context — shared helpers (findSequenceByName,
+// ...) are already defined there.
+//
+// NOT a port — no reference repo has a transition-removal tool. Added in
+// wave 4 as cleanup for add-transition/batch-add-transitions, since undo
+// is confirmed non-functional on this build (see README/undo command).
+// Removal is standard-DOM only: track.transitions[i].remove(false, false)
+// per PREMIERE_API_NOTES.md's "Transitions (QE only)" line, but the
+// remove() ARITY is unconfirmed on this build (0, 1, or 2 args across the
+// reference repos) — probed via an attempts array, verified the only
+// reliable way available: a numItems drop on track.transitions (never the
+// call's own return value). If transitionIndex is out of range, the
+// result includes a transitions LISTING (index + best-effort name) so the
+// caller can find the right index without a separate round trip.
+function ppb_removeTransition(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.transitionIndex !== "number" || args.transitionIndex < 0 || Math.floor(args.transitionIndex) !== args.transitionIndex) {
+      return JSON.stringify({ ok: false, error: "transitionIndex must be a non-negative integer" });
+    }
+
+    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;
+    try { numTracks = trackCollection.numTracks; } catch (eNt) { numTracks = 0; }
+    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 transitions;
+    try {
+      transitions = track.transitions;
+    } catch (eTr) {
+      return JSON.stringify({ ok: false, error: "track.transitions is not available: " + eTr.toString() });
+    }
+    var numTransitions;
+    try { numTransitions = transitions.numItems; } catch (eNi) { numTransitions = null; }
+    if (numTransitions === null) {
+      return JSON.stringify({ ok: false, error: "could not read track.transitions.numItems on this build" });
+    }
+
+    function listTransitions() {
+      var list = [];
+      for (var i = 0; i < numTransitions; i++) {
+        var name = null;
+        try { name = transitions[i].name; } catch (eName) {
+          try { name = transitions[i].displayName; } catch (eName2) { name = null; }
+        }
+        list.push({ index: i, name: name });
+      }
+      return list;
+    }
+
+    if (args.transitionIndex >= numTransitions) {
+      return JSON.stringify({
+        ok: false,
+        error: "transitionIndex " + args.transitionIndex + " is out of range — track has " + numTransitions + " transition(s)",
+        transitions: listTransitions(),
+        count: numTransitions
+      });
+    }
+
+    var removedTransitionName = null;
+    try { removedTransitionName = transitions[args.transitionIndex].name; } catch (eRn) {
+      try { removedTransitionName = transitions[args.transitionIndex].displayName; } catch (eRn2) { removedTransitionName = null; }
+    }
+
+    var previousCount = numTransitions;
+    var attempts = [];
+    var verified = false;
+    var newCount = null;
+
+    function attemptRemove(label, fn) {
+      if (verified) {
+        return;
+      }
+      var entry = { form: label };
+      try {
+        fn();
+        entry.success = true;
+      } catch (eCall) {
+        entry.success = false;
+        entry.error = eCall.toString();
+        attempts.push(entry);
+        return;
+      }
+      var count = null;
+      try { count = track.transitions.numItems; } catch (eCount) { count = null; }
+      if (count !== null && count === previousCount - 1) {
+        entry.verifiedCount = count;
+        verified = true;
+        newCount = count;
+      } else {
+        entry.note = "call did not throw, but transitions count did not drop by exactly one — treating as unverified";
+      }
+      attempts.push(entry);
+    }
+
+    attemptRemove("remove(false, false)", function () {
+      track.transitions[args.transitionIndex].remove(false, false);
+    });
+    attemptRemove("remove(false)", function () {
+      track.transitions[args.transitionIndex].remove(false);
+    });
+    attemptRemove("remove()", function () {
+      track.transitions[args.transitionIndex].remove();
+    });
+    attemptRemove("remove(true, false)", function () {
+      track.transitions[args.transitionIndex].remove(true, false);
+    });
+
+    var result = {
+      sequenceName: seq.name,
+      trackType: args.trackType,
+      trackIndex: args.trackIndex,
+      transitionIndex: args.transitionIndex,
+      removedTransitionName: removedTransitionName,
+      previousCount: previousCount,
+      newCount: newCount,
+      verified: verified,
+      attempts: attempts
+    };
+
+    if (!verified) {
+      result.transitions = listTransitions();
+      return JSON.stringify({ ok: false, error: "could not remove the transition with any known argument form — see attempts", result: result });
+    }
+
+    return JSON.stringify({ ok: true, result: result });
+  } catch (e) {
+    return JSON.stringify({ ok: false, error: e.toString() });
+  }
+}

premiere_cli/panel/host/commands/rename-bin.jsx

@@ -0,0 +1,88 @@
+// Command: rename-bin → ppb_renameBin
+// Loaded lazily by ppb_dispatch (host/index.jsx) on first use, into the
+// same global ExtendScript context — shared helpers (TICKS_PER_SECOND, ...)
+// are already defined there.
+//
+// Ports the reference project's project.ts rename_bin tool. Resolves a
+// '/'-separated bin path (same convention as create-sequence's bin arg and
+// get-bin-contents' binPath — never auto-created here) and renames it via
+// bin.renameBin(newName). Verified via a name read-back. Undo is
+// non-functional on this build — there is no previousValue restoration
+// beyond renaming back manually (oldName is reported).
+
+function ppbRenameBin_resolveBinPath(binPath) {
+  var segments = binPath.split("/").filter(function (s) { return s.length > 0; });
+  if (segments.length === 0) {
+    return { error: "binPath must contain at least one non-empty segment" };
+  }
+  var current = app.project.rootItem;
+  for (var i = 0; i < segments.length; i++) {
+    var found = null;
+    for (var j = 0; j < current.children.numItems; j++) {
+      var child = current.children[j];
+      if (child.name === segments[i] && typeof ProjectItemType !== "undefined" && child.type === ProjectItemType.BIN) {
+        found = child;
+        break;
+      }
+    }
+    if (!found) {
+      return { error: "bin path segment \"" + segments[i] + "\" not found in \"" + binPath + "\"" };
+    }
+    current = found;
+  }
+  return { bin: current };
+}
+
+function ppb_renameBin(argsJson) {
+  try {
+    var args;
+    try {
+      args = JSON.parse(argsJson);
+    } catch (e) {
+      return JSON.stringify({ ok: false, error: "invalid args JSON: " + e.toString() });
+    }
+
+    if (!args.binPath || typeof args.binPath !== "string") {
+      return JSON.stringify({ ok: false, error: "binPath is required" });
+    }
+    if (!args.newName || typeof args.newName !== "string") {
+      return JSON.stringify({ ok: false, error: "newName is required" });
+    }
+
+    if (!app.project) {
+      return JSON.stringify({ ok: false, error: "no project open" });
+    }
+
+    var resolved = ppbRenameBin_resolveBinPath(args.binPath);
+    if (resolved.error) {
+      return JSON.stringify({ ok: false, error: resolved.error });
+    }
+    var bin = resolved.bin;
+
+    var oldName = null;
+    try { oldName = bin.name; } catch (e) { oldName = null; }
+
+    try {
+      bin.renameBin(args.newName);
+    } catch (e) {
+      return JSON.stringify({ ok: false, error: "renameBin() failed: " + e.toString() });
+    }
+
+    var newName = null;
+    try { newName = bin.name; } catch (e) { newName = null; }
+
+    return JSON.stringify({
+      ok: true,
+      result: {
+        binPath: args.binPath,
+        nodeId: bin.nodeId,
+        oldName: oldName,
+        requestedName: args.newName,
+        newName: newName,
+        verified: newName === args.newName
+      }
+    });
+  } catch (e) {
+    return JSON.stringify({ ok: false, error: e.toString() });
+  }
+}

premiere_cli/panel/host/commands/rename-clip.jsx

@@ -0,0 +1,127 @@
+// Command: rename-clip → ppb_renameClip
+// Loaded lazily by ppb_dispatch (host/index.jsx) on first use, into the
+// same global ExtendScript context — shared helpers (findSequenceByName,
+// ensureQEEnabled, activateSequenceForQE, ...) are already defined there.
+//
+// Ported from leancoderkavy's premiere-pro-mcp `rename_clip` tool
+// (advanced.ts), which renames exclusively via the QE DOM (`qeClip.
+// setName()`). PREMIERE_API_NOTES.md's Clips section says standard-DOM
+// `clip.name = x` is also cited as working [hetpatel] — probed FIRST here
+// since it needs no QE activation/tab-switch; falls back to the QE
+// setName() path only if the standard-DOM assignment doesn't stick. Either
+// way, the result is read back from clip.name afterward, never trusted
+// from either mutation call's own success.
+function ppb_renameClip(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.name !== "string" || args.name.length === 0) {
+      return JSON.stringify({ ok: false, error: "name must be a non-empty string" });
+    }
+
+    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 oldName = null;
+    try { oldName = clip.name; } catch (e) { oldName = null; }
+
+    var method = null;
+    var standardDomError = null;
+    try {
+      clip.name = args.name;
+      method = "standardDom";
+    } catch (e) {
+      standardDomError = e.toString();
+    }
+
+    var newName = null;
+    try { newName = clip.name; } catch (e) { newName = null; }
+
+    var qeError = null;
+    if (newName !== args.name) {
+      try {
+        ensureQEEnabled();
+        activateSequenceForQE(seq);
+        var qeSeq = qe.project.getActiveSequence();
+        var qeTrack = args.trackType === "video" ? qeSeq.getVideoTrackAt(args.trackIndex) : qeSeq.getAudioTrackAt(args.trackIndex);
+        var qeClip = qeFindNthNonEmptyClip(qeTrack, args.clipIndex);
+        if (!qeClip) {
+          qeError = "could not locate the corresponding QE clip";
+        } else {
+          qeClip.setName(args.name);
+          method = "qe";
+        }
+      } catch (e) {
+        qeError = e.toString();
+      }
+      try { newName = clip.name; } catch (e) { newName = newName; }
+    }
+
+    var verified = newName === args.name;
+
+    var result = {
+      sequenceName: seq.name,
+      trackType: args.trackType,
+      trackIndex: args.trackIndex,
+      clipIndex: args.clipIndex,
+      previousValue: oldName,
+      requestedValue: args.name,
+      newValue: newName,
+      verified: verified,
+      method: method,
+      standardDomError: standardDomError,
+      qeError: qeError
+    };
+
+    return JSON.stringify({ ok: true, result: result });
+  } catch (e) {
+    return JSON.stringify({ ok: false, error: e.toString() });
+  }
+}

premiere_cli/panel/host/commands/rename-project-item.jsx

@@ -0,0 +1,111 @@
+// Command: rename-project-item → ppb_renameProjectItem
+// Loaded lazily by ppb_dispatch (host/index.jsx) on first use, into the
+// same global ExtendScript context — shared helpers (TICKS_PER_SECOND, ...)
+// are already defined there.
+//
+// Ports the reference project's utility.ts rename_project_item tool. Item
+// resolution by nodeId/name uses children-presence recursion (NOT an
+// isBin() gate), per get-project-item-info.jsx's live-debugged finding.
+// Renames via the documented item.name = x assignment, verified via a
+// name read-back. Undo is non-functional on this build — previousValue is
+// the only restoration path.
+
+function ppbRenameProjectItem_findByNodeId(item, nodeId, depth) {
+  if (depth > 32) {
+    return null;
+  }
+  try {
+    if (item.nodeId === nodeId) {
+      return item;
+    }
+  } catch (e) {
+    // fall through
+  }
+  if (item.children && item.children.numItems > 0) {
+    for (var i = 0; i < item.children.numItems; i++) {
+      var found = ppbRenameProjectItem_findByNodeId(item.children[i], nodeId, depth + 1);
+      if (found) {
+        return found;
+      }
+    }
+  }
+  return null;
+}
+
+function ppbRenameProjectItem_findByName(item, name, depth) {
+  if (depth > 32) {
+    return null;
+  }
+  try {
+    if (item.name === name) {
+      return item;
+    }
+  } catch (e) {
+    // fall through
+  }
+  if (item.children && item.children.numItems > 0) {
+    for (var i = 0; i < item.children.numItems; i++) {
+      var found = ppbRenameProjectItem_findByName(item.children[i], name, depth + 1);
+      if (found) {
+        return found;
+      }
+    }
+  }
+  return null;
+}
+
+function ppb_renameProjectItem(argsJson) {
+  try {
+    var args;
+    try {
+      args = JSON.parse(argsJson);
+    } catch (e) {
+      return JSON.stringify({ ok: false, error: "invalid args JSON: " + e.toString() });
+    }
+
+    var hasNodeId = typeof args.nodeId === "string" && args.nodeId.length > 0;
+    var hasName = typeof args.name === "string" && args.name.length > 0;
+    if (!hasNodeId && !hasName) {
+      return JSON.stringify({ ok: false, error: "either nodeId or name is required" });
+    }
+    if (!args.newName || typeof args.newName !== "string") {
+      return JSON.stringify({ ok: false, error: "newName is required" });
+    }
+
+    if (!app.project) {
+      return JSON.stringify({ ok: false, error: "no project open" });
+    }
+
+    var item = hasNodeId
+      ? ppbRenameProjectItem_findByNodeId(app.project.rootItem, args.nodeId, 0)
+      : ppbRenameProjectItem_findByName(app.project.rootItem, args.name, 0);
+    if (!item) {
+      return JSON.stringify({ ok: false, error: "no project item found matching the given nodeId/name" });
+    }
+
+    var previousValue = null;
+    try { previousValue = item.name; } catch (e) { previousValue = null; }
+
+    try {
+      item.name = args.newName;
+    } catch (e) {
+      return JSON.stringify({ ok: false, error: "setting item.name failed: " + e.toString() });
+    }
+
+    var newValue = null;
+    try { newValue = item.name; } catch (e) { newValue = null; }
+
+    return JSON.stringify({
+      ok: true,
+      result: {
+        nodeId: item.nodeId,
+        previousValue: previousValue,
+        requestedValue: args.newName,
+        newValue: newValue,
+        verified: newValue === args.newName
+      }
+    });
+  } catch (e) {
+    return JSON.stringify({ ok: false, error: e.toString() });
+  }
+}

premiere_cli/panel/host/commands/rename-track.jsx

@@ -0,0 +1,84 @@
+// Command: rename-track → ppb_renameTrack
+// Loaded lazily by ppb_dispatch (host/index.jsx) on first use, into the
+// same global ExtendScript context — shared helpers (findSequenceByName,
+// ...) are already defined there.
+//
+// Standard-DOM mutation. Ported from leancoderkavy's premiere-pro-mcp
+// `rename_track` tool (track-targeting.ts) — plain track.name assignment.
+// Verified by reading track.name back afterward.
+function ppb_renameTrack(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.name !== "string" || args.name.length === 0) {
+      return JSON.stringify({ ok: false, error: "name must be a non-empty string" });
+    }
+
+    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 oldName = null;
+    try { oldName = track.name; } catch (e) { oldName = null; }
+
+    try {
+      track.name = args.name;
+    } catch (e) {
+      return JSON.stringify({ ok: false, error: "track.name assignment failed: " + e.toString() });
+    }
+
+    var newName = null;
+    try { newName = track.name; } catch (e) { newName = null; }
+
+    var result = {
+      sequenceName: seq.name,
+      trackType: args.trackType,
+      trackIndex: args.trackIndex,
+      oldName: oldName,
+      requestedName: args.name,
+      newName: newName
+    };
+
+    if (newName !== null && newName !== args.name) {
+      result.warning = "track.name read back \"" + newName + "\" after requesting \"" + args.name + "\" — mutation may not have taken effect";
+    }
+
+    return JSON.stringify({ ok: true, result: result });
+  } catch (e) {
+    return JSON.stringify({ ok: false, error: e.toString() });
+  }
+}