@hadialmarzooq/agent-media-cli 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Hadi Almarzooq
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/index.d.ts

@@ -0,0 +1,6 @@
+#!/usr/bin/env node
+import { Command } from 'commander';
+
+declare function createProgram(): Command;
+
+export { createProgram };

package/dist/index.js

@@ -0,0 +1,178 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { realpathSync } from "fs";
+import { readFile, writeFile } from "fs/promises";
+import { createRequire } from "module";
+import { fileURLToPath } from "url";
+import { Command } from "commander";
+import {
+  MediaError,
+  parsePlan,
+  planMedia,
+  serializePlan,
+  verifyMedia
+} from "@hadialmarzooq/agent-media-core";
+import {
+  executePlan,
+  getCapabilities,
+  inspectMedia,
+  makeVertical,
+  optimizeForWeb,
+  normalize,
+  extractAudio,
+  extractFrame
+} from "@hadialmarzooq/agent-media-ffmpeg";
+var packageVersion = createRequire(import.meta.url)("../package.json").version;
+function createProgram() {
+  const program = new Command();
+  program.name("agent-media").description("Deterministic semantic media transformations.").version(packageVersion);
+  program.command("inspect <input>").description("Inspect media metadata.").action(async (input) => print(await inspectMedia(input)));
+  program.command("capabilities").description("Detect local FFmpeg capabilities.").action(async () => print(await getCapabilities()));
+  program.command("plan <input>").description("Create a versioned semantic media plan.").option("--trim-start <seconds>", "trim start in seconds", Number).option("--duration <seconds>", "output duration in seconds", Number).option("--aspect <ratio>", "target aspect ratio, e.g. 9:16").option("--width <pixels>", "target width", Number).option("--height <pixels>", "target height", Number).option("--max-size <mb>", "maximum file size in MB", Number).option("--compatibility <level>", "high or balanced").option("--quality <level>", "high, balanced, or small").option("--remove-audio", "remove audio").option("--out <path>", "write the plan JSON to a file").action(async (input, options) => {
+    const plan = planMedia({
+      source: await inspectMedia(input),
+      goals: {
+        trimStartSeconds: options.trimStart,
+        durationSeconds: options.duration,
+        aspectRatio: options.aspect,
+        width: options.width,
+        height: options.height,
+        maxSizeMB: options.maxSize,
+        compatibility: options.compatibility,
+        quality: options.quality,
+        ...options.removeAudio ? { audio: "remove" } : {}
+      },
+      capabilities: await getCapabilities()
+    });
+    const serialized = serializePlan(plan);
+    if (options.out !== void 0) await writeFile(options.out, `${serialized}
+`, "utf8");
+    print(plan);
+  });
+  program.command("vertical <input>").description("Create and verify a high-compatibility 9:16 video.").requiredOption("--output <path>", "output media path").option("--width <pixels>", "target width (requires --height)", Number).option("--height <pixels>", "target height (requires --width)", Number).option("--trim-start <seconds>", "trim start in seconds", Number).option("--duration <seconds>", "output duration in seconds", Number).option("--max-size <mb>", "maximum file size in MB", Number).option("--remove-audio", "remove audio").option("--overwrite", "allow output replacement").option("--progress", "write NDJSON progress events to stderr").action(async (input, options) => {
+    const onProgress = progressWriter(Boolean(options.progress));
+    print(
+      await makeVertical({
+        input,
+        output: options.output,
+        width: options.width,
+        height: options.height,
+        trimStartSeconds: options.trimStart,
+        durationSeconds: options.duration,
+        maxSizeMB: options.maxSize,
+        ...options.removeAudio ? { audio: "remove" } : {},
+        overwrite: options.overwrite,
+        ...onProgress === void 0 ? {} : { onProgress }
+      })
+    );
+  });
+  program.command("optimize <input>").description("Create and verify a web-optimized high-compatibility video.").requiredOption("--output <path>", "output media path").option("--trim-start <seconds>", "trim start in seconds", Number).option("--duration <seconds>", "output duration in seconds", Number).option("--max-size <mb>", "maximum file size in MB", Number).option("--quality <level>", "high, balanced, or small").option("--remove-audio", "remove audio").option("--overwrite", "allow output replacement").option("--progress", "write NDJSON progress events to stderr").action(async (input, options) => {
+    const onProgress = progressWriter(Boolean(options.progress));
+    print(
+      await optimizeForWeb({
+        input,
+        output: options.output,
+        trimStartSeconds: options.trimStart,
+        durationSeconds: options.duration,
+        maxSizeMB: options.maxSize,
+        ...options.quality === void 0 ? {} : { quality: options.quality },
+        ...options.removeAudio ? { audio: "remove" } : {},
+        overwrite: options.overwrite,
+        ...onProgress === void 0 ? {} : { onProgress }
+      })
+    );
+  });
+  program.command("normalize <input>").description("Create and verify a normalized high-compatibility copy.").requiredOption("--output <path>", "output media path").option("--trim-start <seconds>", "trim start in seconds", Number).option("--duration <seconds>", "output duration in seconds", Number).option("--remove-audio", "remove audio").option("--overwrite", "allow output replacement").option("--progress", "write NDJSON progress events to stderr").action(async (input, options) => {
+    const onProgress = progressWriter(Boolean(options.progress));
+    print(
+      await normalize({
+        input,
+        output: options.output,
+        trimStartSeconds: options.trimStart,
+        durationSeconds: options.duration,
+        ...options.removeAudio ? { audio: "remove" } : {},
+        overwrite: options.overwrite,
+        ...onProgress === void 0 ? {} : { onProgress }
+      })
+    );
+  });
+  program.command("extract-audio <input>").description("Extract and verify audio from any media source.").requiredOption("--output <path>", "output audio path").option("--format <format>", "m4a, mp3, or wav").option("--trim-start <seconds>", "trim start in seconds", Number).option("--duration <seconds>", "output duration in seconds", Number).option("--overwrite", "allow output replacement").option("--progress", "write NDJSON progress events to stderr").action(async (input, options) => {
+    const onProgress = progressWriter(Boolean(options.progress));
+    print(
+      await extractAudio({
+        input,
+        output: options.output,
+        ...options.format === void 0 ? {} : { format: options.format },
+        trimStartSeconds: options.trimStart,
+        durationSeconds: options.duration,
+        overwrite: options.overwrite,
+        ...onProgress === void 0 ? {} : { onProgress }
+      })
+    );
+  });
+  program.command("extract-frame <input>").description("Extract and verify a still frame from a video source.").requiredOption("--output <path>", "output frame path").option("--at <seconds>", "frame timestamp in seconds", Number).option("--format <format>", "jpg or png").option("--overwrite", "allow output replacement").option("--progress", "write NDJSON progress events to stderr").action(async (input, options) => {
+    const onProgress = progressWriter(Boolean(options.progress));
+    print(
+      await extractFrame({
+        input,
+        output: options.output,
+        ...options.at === void 0 ? {} : { atSeconds: options.at },
+        ...options.format === void 0 ? {} : { format: options.format },
+        overwrite: options.overwrite,
+        ...onProgress === void 0 ? {} : { onProgress }
+      })
+    );
+  });
+  program.command("execute <plan>").description("Execute a saved plan.").requiredOption("--output <path>", "output media path").option("--overwrite", "allow output replacement").option("--progress", "write NDJSON progress events to stderr").action(async (planPath, options) => {
+    const plan = parsePlan(await readFile(planPath, "utf8"));
+    const onProgress = progressWriter(Boolean(options.progress));
+    const result = await executePlan(plan, {
+      output: options.output,
+      overwrite: options.overwrite,
+      ...onProgress === void 0 ? {} : { onProgress }
+    });
+    print({
+      output: result.output,
+      verification: verifyMedia(await inspectMedia(result.output), plan.expectations)
+    });
+  });
+  program.command("verify <output>").description("Verify an output against a saved plan.").requiredOption("--against <plan>", "plan JSON path").action(async (outputPath, options) => {
+    const plan = parsePlan(await readFile(options.against, "utf8"));
+    print(verifyMedia(await inspectMedia(outputPath), plan.expectations));
+  });
+  return program;
+}
+function print(value) {
+  process.stdout.write(`${JSON.stringify(value, null, 2)}
+`);
+}
+function progressWriter(enabled) {
+  if (!enabled) return void 0;
+  return (progress) => {
+    process.stderr.write(`${JSON.stringify({ type: "progress", ...progress })}
+`);
+  };
+}
+if (isMainModule()) {
+  createProgram().parseAsync().catch((error) => {
+    const output = error instanceof MediaError ? error.toJSON() : {
+      code: "UNEXPECTED_ERROR",
+      message: error instanceof Error ? error.message : String(error)
+    };
+    process.stderr.write(`${JSON.stringify(output)}
+`);
+    process.exitCode = 1;
+  });
+}
+function isMainModule() {
+  if (process.argv[1] === void 0) return false;
+  try {
+    return realpathSync(process.argv[1]) === realpathSync(fileURLToPath(import.meta.url));
+  } catch {
+    return false;
+  }
+}
+export {
+  createProgram
+};

package/package.json

@@ -0,0 +1,46 @@
+{
+  "name": "@hadialmarzooq/agent-media-cli",
+  "version": "0.1.0",
+  "description": "JSON-first CLI for deterministic, verified media workflows.",
+  "keywords": [
+    "media",
+    "agents",
+    "ffmpeg",
+    "cli",
+    "automation"
+  ],
+  "homepage": "https://github.com/HadiAlMarzooq/agent-media#readme",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/HadiAlMarzooq/agent-media.git",
+    "directory": "packages/cli"
+  },
+  "bugs": {
+    "url": "https://github.com/HadiAlMarzooq/agent-media/issues"
+  },
+  "license": "MIT",
+  "engines": {
+    "node": ">=22.0.0"
+  },
+  "type": "module",
+  "bin": {
+    "agent-media": "./dist/index.js"
+  },
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "commander": "15.0.0",
+    "@hadialmarzooq/agent-media-core": "0.1.0",
+    "@hadialmarzooq/agent-media-ffmpeg": "0.1.0"
+  },
+  "scripts": {
+    "build": "tsup src/index.ts --format esm --dts",
+    "typecheck": "tsc --noEmit"
+  }
+}