@shaztech/video-cutter 1.0.0 → 1.1.0

package/.github/workflows/ci.yml

@@ -0,0 +1,19 @@
+name: CI
+
+on:
+  push:
+    branches:
+      - main
+  pull_request:
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-node@v4
+        with:
+          node-version: '20'
+          cache: 'npm'
+      - run: npm ci
+      - run: npm test

package/.github/workflows/publish.yml

@@ -0,0 +1,21 @@
+name: Publish to npm
+
+on:
+  release:
+    types: [published]
+
+jobs:
+  publish:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-node@v4
+        with:
+          node-version: '20'
+          cache: 'npm'
+          registry-url: 'https://registry.npmjs.org'
+      - run: npm ci
+      - run: npm test
+      - run: npm publish
+        env:
+          NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }}

package/README.md

@@ -1,6 +1,6 @@
 # Video Cutter
 
-A simple CLI tool to cut a video file into equal-length segments using ffmpeg.
+A CLI tool to cut a video file into segments using ffmpeg — by equal count, fixed duration, or automatic scene change detection.
 
 ## Prerequisites
 
@@ -30,17 +30,19 @@ video-cutter [options]
 
 Options:
 ```text
-  -V, --version             output the version number
-  -i, --input <path>        input video file path
-  -n, --segments <number>   number of segments to create
-  -d, --duration <seconds>  duration of each segment in seconds
-  -o, --output <path>       output directory for segments (default:
-                            ./output/YYYY-MM-DD_HH-MM-SS/)
-  --verify                  verify that each segment matches its intended
-                            duration
-  --re-encode               re-encode segments for exact duration (slower but
-                            more accurate)
-  -h, --help                display help for command
+  -V, --version                  output the version number
+  -i, --input <path>             input video file path
+  -n, --segments <number>        number of segments to create
+  -d, --duration <seconds>       duration of each segment in seconds
+  --scene-detect [threshold]     cut at scene change boundaries (threshold
+                                 0–100, default: 10)
+  -o, --output <path>            output directory for segments (default:
+                                 ./output/YYYY-MM-DD_HH-MM-SS/)
+  --verify                       verify that each segment matches its intended
+                                 duration
+  --re-encode                    re-encode segments for exact duration (slower
+                                 but more accurate)
+  -h, --help                     display help for command
 ```
 
 ## Examples
@@ -63,6 +65,32 @@ This will create files named `seg_01_00-00-00.mp4`, `seg_02_00-00-30.mp4`, etc.
 
 **Note:** When using the `-d` flag without `--re-encode`, segment durations may not be exactly as specified due to keyframe alignment when stream copying. For exact durations, use the `--re-encode` flag.
 
+### Cut a video at scene changes (automatic detection):
+
+```bash
+video-cutter -i my_video.mp4 --scene-detect
+```
+
+This detects hard cuts between scenes and creates one segment per scene, named `scene_001.mp4`, `scene_002.mp4`, etc. The number of segments is content-driven — it depends entirely on what's in the video.
+
+### Cut at scene changes with a custom threshold:
+
+```bash
+video-cutter -i my_video.mp4 --scene-detect 20
+```
+
+The threshold (0–100) controls sensitivity to scene changes. It represents the minimum per-frame difference score required to count as a scene cut:
+
+| Threshold | Behaviour |
+|-----------|-----------|
+| 2–5       | Very sensitive — catches subtle transitions and fades; may produce false positives |
+| **8–14**  | **Recommended range** — reliably detects hard cuts with few false positives |
+| 20–30     | Only dramatic, obvious cuts; may miss some real scene changes |
+
+The default is **10**. Raise it if you are getting too many segments; lower it if real cuts are being missed.
+
+**Note:** File paths containing `:` or `,` may cause scene detection to fail due to limitations in the ffmpeg lavfi filter string format.
+
 ### Specify custom output directory:
 
 ```bash
@@ -77,8 +105,10 @@ video-cutter -i my_video.mp4 -n 10 -o ./my_segments/
 - When creating segments shorter than 30 seconds, you'll be prompted for confirmation
 - Segment numbers are zero-padded to 3 digits (001, 002, etc.) for count-based segments
 - Time-based segments are named with both sequence number and start time (e.g., seg_01_00-00-00.mp4)
-- The `--segments` and `--duration` options are mutually exclusive
+- The `--segments`, `--duration`, and `--scene-detect` options are mutually exclusive
 - By default, the tool uses stream copying for fast segment creation, which may result in slight duration inaccuracies due to keyframe alignment
 - Use the `--re-encode` flag to re-encode segments for precise duration control (slower but exact)
 - Use the `--verify` flag to check that each segment matches its intended duration after creation
-- When using both `--re-encode` and `--verify`, segments will have exact durations as specified
+- When using both `--re-encode` and `--verify`, segments will have exact durations as specified
+- Scene-detect segments are named `scene_001.mp4`, `scene_002.mp4`, etc.
+- The `--scene-detect` threshold is a value from 0–100 representing the minimum frame difference score to trigger a cut; the recommended range is 8–14 (default: 10)

package/index.js

@@ -23,7 +23,9 @@ import colors from 'colors'
 import {
   getVideoDuration,
   createCountSegments,
-  createTimeSegments
+  createTimeSegments,
+  detectSceneChanges,
+  createSceneSegments
 } from './src/core.js'
 
 // Colored console output helpers
@@ -95,7 +97,24 @@ async function processVideo (options) {
 
     console.log(`Video duration: ${duration} seconds`)
 
-    if (segmentDuration) {
+    const sceneDetect = options.sceneDetect ?? null
+    const threshold = sceneDetect === true ? 10 : (sceneDetect ? parseInt(sceneDetect) : null)
+
+    if (sceneDetect !== null) {
+      console.log(`Detecting scene changes with threshold: ${threshold}...`)
+      const timestamps = await detectSceneChanges(inputFile, threshold)
+      if (timestamps.length <= 1) {
+        console.warn('No scene changes detected. Cannot create segments.')
+        process.exit(0)
+      }
+      const boundaries = [...timestamps, duration]
+      console.log('boundaries:', boundaries)
+      console.log(`${boundaries.length - 1} scene segment(s) will be created.`)
+      if (!reEncode) {
+        console.warn('Using stream copy mode. Durations may vary slightly. Use --re-encode for exact cuts.')
+      }
+      return createSceneSegments(inputFile, outputPath, boundaries, verifySegments, reEncode)
+    } else if (segmentDuration) {
       // Time-based segmentation
       const calculatedSegmentCount = Math.ceil(duration / segmentDuration)
       console.log(`${calculatedSegmentCount} segments will be created.`)
@@ -183,6 +202,11 @@ function setupCli () {
     .requiredOption('-i, --input <path>', 'input video file path')
     .addOption(new Option('-n, --segments <number>', 'number of segments to create').conflicts('duration'))
     .addOption(new Option('-d, --duration <seconds>', 'duration of each segment in seconds').conflicts('segments'))
+    .addOption(
+      new Option('--scene-detect [threshold]', 'cut at scene change boundaries (threshold 0–100, default: 10)')
+        .conflicts('segments')
+        .conflicts('duration')
+    )
     .option('-o, --output <path>', 'output directory for segments (default: ./output/YYYY-MM-DD_HH-MM-SS/)')
     .option('--verify', 'verify that each segment matches its intended duration')
     .option('--re-encode', 're-encode segments for exact duration (slower but more accurate)')

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@shaztech/video-cutter",
-  "version": "1.0.0",
+  "version": "1.1.0",
   "type": "module",
   "description": "A CLI tool to cut videos into segments using ffmpeg",
   "main": "index.js",
@@ -43,5 +43,8 @@
   "repository": {
     "type": "git",
     "url": "git+https://github.com/shazron/video-cutter.git"
+  },
+  "publishConfig": {
+    "access": "public"
   }
 }

package/src/core.js

@@ -101,12 +101,14 @@ function createSegment (inputFile, startTime, endTime, outputFile, reEncode = fa
       // Log progress if needed
     })
 
+    let stderrOutput = ''
     ffmpeg.stderr.on('data', (data) => {
-      // Handle errors
+      stderrOutput += data.toString()
     })
 
     ffmpeg.on('close', (code) => {
       if (code !== 0) {
+        if (stderrOutput) console.error(stderrOutput)
         reject(new Error(`ffmpeg exited with code ${code}`))
       } else {
         resolve()
@@ -243,9 +245,96 @@ async function createTimeSegments (inputFile, videoDuration, segmentDuration, ou
     })
 }
 
+/**
+ * Detect scene changes using ffprobe's scdet filter
+ *
+ * Note: file paths containing `:` or `,` may break the lavfi filter string.
+ *
+ * @param {string} inputFile - Path to the input video file
+ * @param {number} threshold - Scene change sensitivity (0–100, default: 10)
+ * @returns {Promise<number[]>} - Array of timestamps (always starts with 0)
+ */
+async function detectSceneChanges (inputFile, threshold = 10) {
+  return new Promise((resolve, reject) => {
+    const args = [
+      '-v', 'quiet',
+      '-f', 'lavfi',
+      '-i', `movie=${inputFile},scdet=threshold=${threshold}:sc_pass=1`,
+      '-show_frames', '-select_streams', 'v:0',
+      '-of', 'json'
+    ]
+    const proc = spawn('ffprobe', args)
+    let output = ''
+    proc.stdout.on('data', chunk => { output += chunk })
+    proc.on('close', code => {
+      if (code !== 0) return reject(new Error(`ffprobe exited with code ${code}`))
+      let parsed
+      try { parsed = JSON.parse(output) } catch {
+        return reject(new Error('Could not parse scene detection output'))
+      }
+      const frames = parsed.frames ?? []
+      const timestamps = frames.map(f => parseFloat(f.pts_time ?? f.pkt_pts_time))
+      const result = timestamps.length > 0 && timestamps[0] === 0
+        ? timestamps
+        : [0, ...timestamps]
+      resolve(result)
+    })
+  })
+}
+
+/**
+ * Create video segments at scene change boundaries
+ *
+ * @param {string} inputFile - Path to the input video file
+ * @param {string} outputDir - Directory to save the segments
+ * @param {number[]} boundaries - Array of timestamps including 0 at start and total duration at end
+ * @param {boolean} verifySegments - Whether to verify segment durations
+ * @param {boolean} reEncode - Whether to re-encode for exact duration
+ * @returns {Promise<void>}
+ */
+async function createSceneSegments (inputFile, outputDir, boundaries, verifySegments = false, reEncode = false) {
+  const segmentCount = boundaries.length - 1
+  const promises = []
+
+  for (let i = 0; i < segmentCount; i++) {
+    const startTime = boundaries[i]
+    const endTime = boundaries[i + 1]
+    const segmentFile = path.join(outputDir, `scene_${String(i + 1).padStart(3, '0')}.mp4`)
+    promises.push(createSegment(inputFile, startTime, endTime, segmentFile, reEncode))
+  }
+
+  return Promise.all(promises)
+    .then(async () => {
+      console.log('All segments created successfully!')
+
+      if (verifySegments) {
+        console.log('Verifying segment durations...')
+        for (let i = 0; i < segmentCount; i++) {
+          const expectedDuration = boundaries[i + 1] - boundaries[i]
+          const segmentFile = path.join(outputDir, `scene_${String(i + 1).padStart(3, '0')}.mp4`)
+
+          const actualDuration = await getVideoDuration(segmentFile)
+          const difference = Math.abs(actualDuration - expectedDuration)
+          const tolerance = reEncode ? 0.1 : 1.0
+          if (difference > tolerance) {
+            console.warn(`Warning: Segment ${segmentFile} duration is ${actualDuration.toFixed(2)} seconds, expected ${expectedDuration.toFixed(2)} seconds`)
+          } else {
+            console.log(colors.green(`Verified: ${segmentFile} duration is correct`))
+          }
+        }
+      }
+    })
+    .catch(err => {
+      console.error('Error creating segments:', err)
+      process.exit(1)
+    })
+}
+
 export {
   getVideoDuration,
   createSegment,
   createCountSegments,
-  createTimeSegments
+  createTimeSegments,
+  detectSceneChanges,
+  createSceneSegments
 }

package/tests/cli-direct.spec.js

@@ -32,7 +32,9 @@ describe('index.js invoked directly as main module', () => {
     vi.doMock('../src/core.js', () => ({
       getVideoDuration: vi.fn(),
       createCountSegments: vi.fn(),
-      createTimeSegments: vi.fn()
+      createTimeSegments: vi.fn(),
+      detectSceneChanges: vi.fn(),
+      createSceneSegments: vi.fn()
     }))
     vi.doMock('commander', () => {
       const mockProgram = {
@@ -75,7 +77,9 @@ describe('index.js invoked directly as main module', () => {
     vi.doMock('../src/core.js', () => ({
       getVideoDuration: vi.fn(),
       createCountSegments: vi.fn(),
-      createTimeSegments: vi.fn()
+      createTimeSegments: vi.fn(),
+      detectSceneChanges: vi.fn(),
+      createSceneSegments: vi.fn()
     }))
     const parseMock = vi.fn()
     vi.doMock('commander', () => {

package/tests/core.spec.js

@@ -16,7 +16,7 @@ import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest'
 import { EventEmitter } from 'events'
 
 import { spawn } from 'child_process'
-import { getVideoDuration, createSegment, createCountSegments, createTimeSegments } from '../src/core.js'
+import { getVideoDuration, createSegment, createCountSegments, createTimeSegments, detectSceneChanges, createSceneSegments } from '../src/core.js'
 
 vi.mock('child_process', () => ({
   spawn: vi.fn()
@@ -199,3 +199,136 @@ describe('createTimeSegments', () => {
     expect(exitSpy).toHaveBeenCalledWith(1)
   })
 })
+
+describe('detectSceneChanges', () => {
+  beforeEach(() => vi.clearAllMocks())
+  afterEach(() => vi.restoreAllMocks())
+
+  it('resolves with timestamps when frames are returned using pts_time (ffmpeg 7+)', async () => {
+    const framesJson = JSON.stringify({
+      frames: [
+        { pts_time: '5.2' },
+        { pts_time: '12.8' }
+      ]
+    })
+    vi.mocked(spawn).mockReturnValueOnce(createMockProcess({ stdoutData: framesJson }))
+    const result = await detectSceneChanges('video.mp4')
+    expect(result).toEqual([0, 5.2, 12.8])
+  })
+
+  it('resolves with timestamps when frames are returned using pkt_pts_time fallback (ffmpeg <7)', async () => {
+    const framesJson = JSON.stringify({
+      frames: [
+        { pkt_pts_time: '5.2' },
+        { pkt_pts_time: '12.8' }
+      ]
+    })
+    vi.mocked(spawn).mockReturnValueOnce(createMockProcess({ stdoutData: framesJson }))
+    const result = await detectSceneChanges('video.mp4')
+    expect(result).toEqual([0, 5.2, 12.8])
+  })
+
+  it('resolves with [0] when frames array is empty', async () => {
+    const framesJson = JSON.stringify({ frames: [] })
+    vi.mocked(spawn).mockReturnValueOnce(createMockProcess({ stdoutData: framesJson }))
+    const result = await detectSceneChanges('video.mp4')
+    expect(result).toEqual([0])
+  })
+
+  it('resolves with [0] when frames key is missing (malformed JSON object)', async () => {
+    const framesJson = JSON.stringify({})
+    vi.mocked(spawn).mockReturnValueOnce(createMockProcess({ stdoutData: framesJson }))
+    const result = await detectSceneChanges('video.mp4')
+    expect(result).toEqual([0])
+  })
+
+  it('rejects on non-zero exit code', async () => {
+    vi.mocked(spawn).mockReturnValueOnce(createMockProcess({ exitCode: 1 }))
+    await expect(detectSceneChanges('video.mp4')).rejects.toThrow('ffprobe exited with code 1')
+  })
+
+  it('rejects when stdout is not valid JSON', async () => {
+    vi.mocked(spawn).mockReturnValueOnce(createMockProcess({ stdoutData: 'not-json' }))
+    await expect(detectSceneChanges('video.mp4')).rejects.toThrow('Could not parse scene detection output')
+  })
+
+  it('uses default threshold 10 in spawn args', async () => {
+    const framesJson = JSON.stringify({ frames: [] })
+    vi.mocked(spawn).mockReturnValueOnce(createMockProcess({ stdoutData: framesJson }))
+    await detectSceneChanges('video.mp4')
+    expect(spawn).toHaveBeenCalledWith('ffprobe', expect.arrayContaining([
+      expect.stringContaining('threshold=10')
+    ]))
+  })
+
+  it('uses provided threshold in spawn args', async () => {
+    const framesJson = JSON.stringify({ frames: [] })
+    vi.mocked(spawn).mockReturnValueOnce(createMockProcess({ stdoutData: framesJson }))
+    await detectSceneChanges('video.mp4', 25)
+    expect(spawn).toHaveBeenCalledWith('ffprobe', expect.arrayContaining([
+      expect.stringContaining('threshold=25')
+    ]))
+  })
+
+  it('does not duplicate 0 if first frame timestamp is already 0', async () => {
+    const framesJson = JSON.stringify({
+      frames: [
+        { pts_time: '0' },
+        { pts_time: '8.5' }
+      ]
+    })
+    vi.mocked(spawn).mockReturnValueOnce(createMockProcess({ stdoutData: framesJson }))
+    const result = await detectSceneChanges('video.mp4')
+    expect(result[0]).toBe(0)
+    expect(result.filter(t => t === 0)).toHaveLength(1)
+  })
+})
+
+describe('createSceneSegments', () => {
+  beforeEach(() => {
+    vi.clearAllMocks()
+    vi.spyOn(console, 'log').mockImplementation(() => {})
+    vi.spyOn(console, 'warn').mockImplementation(() => {})
+    vi.spyOn(console, 'error').mockImplementation(() => {})
+  })
+  afterEach(() => vi.restoreAllMocks())
+
+  it('creates N-1 segments from N boundaries with scene_NNN.mp4 filenames', async () => {
+    vi.mocked(spawn)
+      .mockReturnValueOnce(createMockProcess())
+      .mockReturnValueOnce(createMockProcess())
+    await expect(createSceneSegments('video.mp4', '/output', [0, 5.2, 30])).resolves.toBeUndefined()
+    expect(spawn).toHaveBeenCalledTimes(2)
+    expect(spawn).toHaveBeenCalledWith('ffmpeg', expect.arrayContaining([expect.stringContaining('scene_001.mp4')]))
+    expect(spawn).toHaveBeenCalledWith('ffmpeg', expect.arrayContaining([expect.stringContaining('scene_002.mp4')]))
+  })
+
+  it('passes reEncode=true through to spawn args (-c:v libx264)', async () => {
+    vi.mocked(spawn).mockReturnValueOnce(createMockProcess())
+    await createSceneSegments('video.mp4', '/output', [0, 30], false, true)
+    expect(spawn).toHaveBeenCalledWith('ffmpeg', expect.arrayContaining(['-c:v', 'libx264']))
+  })
+
+  it('verifies durations when verifySegments=true', async () => {
+    vi.mocked(spawn)
+      .mockReturnValueOnce(createMockProcess())
+      .mockReturnValueOnce(createMockProcess({ stdoutData: '30.0\n' }))
+    await createSceneSegments('video.mp4', '/output', [0, 30], true)
+    expect(console.log).toHaveBeenCalledWith(expect.stringContaining('Verified'))
+  })
+
+  it('warns on duration mismatch during verification', async () => {
+    vi.mocked(spawn)
+      .mockReturnValueOnce(createMockProcess())
+      .mockReturnValueOnce(createMockProcess({ stdoutData: '1.0\n' })) // expected 30s
+    await createSceneSegments('video.mp4', '/output', [0, 30], true)
+    expect(console.warn).toHaveBeenCalled()
+  })
+
+  it('calls process.exit(1) on segment creation failure', async () => {
+    const exitSpy = vi.spyOn(process, 'exit').mockImplementation(() => { throw new Error('exit') })
+    vi.mocked(spawn).mockReturnValueOnce(createMockProcess({ exitCode: 1 }))
+    await expect(createSceneSegments('video.mp4', '/output', [0, 5.2, 30])).rejects.toThrow('exit')
+    expect(exitSpy).toHaveBeenCalledWith(1)
+  })
+})

package/tests/ffmpeg-check.spec.js

@@ -27,7 +27,9 @@ describe('module-level ffmpeg/ffprobe check', () => {
     vi.doMock('../src/core.js', () => ({
       getVideoDuration: vi.fn(),
       createCountSegments: vi.fn(),
-      createTimeSegments: vi.fn()
+      createTimeSegments: vi.fn(),
+      detectSceneChanges: vi.fn(),
+      createSceneSegments: vi.fn()
     }))
     vi.doMock('commander', () => {
       const mockProgram = {

package/tests/index.spec.js

@@ -17,7 +17,7 @@ import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest'
 import fs from 'fs'
 import inquirer from 'inquirer'
 import { Command } from 'commander'
-import { getVideoDuration, createCountSegments, createTimeSegments } from '../src/core.js'
+import { getVideoDuration, createCountSegments, createTimeSegments, detectSceneChanges, createSceneSegments } from '../src/core.js'
 import { processVideo, setupCli } from '../index.js'
 
 vi.mock('child_process', () => ({
@@ -28,7 +28,9 @@ vi.mock('child_process', () => ({
 vi.mock('../src/core.js', () => ({
   getVideoDuration: vi.fn(),
   createCountSegments: vi.fn(),
-  createTimeSegments: vi.fn()
+  createTimeSegments: vi.fn(),
+  detectSceneChanges: vi.fn(),
+  createSceneSegments: vi.fn()
 }))
 
 vi.mock('commander', () => {
@@ -229,6 +231,85 @@ describe('processVideo', () => {
       expect(createCountSegments).toHaveBeenCalledWith('video.mp4', 120, 2, '/out', true, true)
     })
   })
+
+  describe('scene-detect segmentation (--scene-detect)', () => {
+    it('calls detectSceneChanges with threshold 10 when sceneDetect is true', async () => {
+      vi.spyOn(fs, 'existsSync').mockReturnValue(true)
+      vi.mocked(getVideoDuration).mockResolvedValue(120)
+      vi.mocked(detectSceneChanges).mockResolvedValue([0, 5.2, 12.8])
+      vi.mocked(createSceneSegments).mockResolvedValue()
+
+      await processVideo({ input: 'video.mp4', output: '/out', sceneDetect: true })
+
+      expect(detectSceneChanges).toHaveBeenCalledWith('video.mp4', 10)
+    })
+
+    it('calls detectSceneChanges with parsed threshold when sceneDetect is a string', async () => {
+      vi.spyOn(fs, 'existsSync').mockReturnValue(true)
+      vi.mocked(getVideoDuration).mockResolvedValue(120)
+      vi.mocked(detectSceneChanges).mockResolvedValue([0, 5.2, 12.8])
+      vi.mocked(createSceneSegments).mockResolvedValue()
+
+      await processVideo({ input: 'video.mp4', output: '/out', sceneDetect: '25' })
+
+      expect(detectSceneChanges).toHaveBeenCalledWith('video.mp4', 25)
+    })
+
+    it('appends duration to boundaries before calling createSceneSegments', async () => {
+      vi.spyOn(fs, 'existsSync').mockReturnValue(true)
+      vi.mocked(getVideoDuration).mockResolvedValue(120)
+      vi.mocked(detectSceneChanges).mockResolvedValue([0, 5.2, 12.8])
+      vi.mocked(createSceneSegments).mockResolvedValue()
+
+      await processVideo({ input: 'video.mp4', output: '/out', sceneDetect: true })
+
+      expect(createSceneSegments).toHaveBeenCalledWith('video.mp4', '/out', [0, 5.2, 12.8, 120], false, false)
+    })
+
+    it('exits with code 0 and warns when only [0] is returned (no scenes)', async () => {
+      vi.spyOn(fs, 'existsSync').mockReturnValue(true)
+      vi.mocked(getVideoDuration).mockResolvedValue(120)
+      vi.mocked(detectSceneChanges).mockResolvedValue([0])
+      const exitSpy = vi.spyOn(process, 'exit').mockImplementation(() => { throw new Error('exit') })
+
+      await expect(processVideo({ input: 'video.mp4', output: '/out', sceneDetect: true })).rejects.toThrow('exit')
+      expect(exitSpy).toHaveBeenCalledWith(0)
+      expect(console.warn).toHaveBeenCalledWith(expect.stringContaining('No scene changes detected'))
+    })
+
+    it('warns about stream copy mode when not re-encoding', async () => {
+      vi.spyOn(fs, 'existsSync').mockReturnValue(true)
+      vi.mocked(getVideoDuration).mockResolvedValue(120)
+      vi.mocked(detectSceneChanges).mockResolvedValue([0, 5.2, 12.8])
+      vi.mocked(createSceneSegments).mockResolvedValue()
+
+      await processVideo({ input: 'video.mp4', output: '/out', sceneDetect: true })
+
+      expect(console.warn).toHaveBeenCalledWith(expect.stringContaining('stream copy mode'))
+    })
+
+    it('does not warn about stream copy when reEncode is true', async () => {
+      vi.spyOn(fs, 'existsSync').mockReturnValue(true)
+      vi.mocked(getVideoDuration).mockResolvedValue(120)
+      vi.mocked(detectSceneChanges).mockResolvedValue([0, 5.2, 12.8])
+      vi.mocked(createSceneSegments).mockResolvedValue()
+
+      await processVideo({ input: 'video.mp4', output: '/out', sceneDetect: true, reEncode: true })
+
+      expect(console.warn).not.toHaveBeenCalled()
+    })
+
+    it('passes verify and reEncode flags correctly to createSceneSegments', async () => {
+      vi.spyOn(fs, 'existsSync').mockReturnValue(true)
+      vi.mocked(getVideoDuration).mockResolvedValue(120)
+      vi.mocked(detectSceneChanges).mockResolvedValue([0, 5.2, 12.8])
+      vi.mocked(createSceneSegments).mockResolvedValue()
+
+      await processVideo({ input: 'video.mp4', output: '/out', sceneDetect: true, verify: true, reEncode: true })
+
+      expect(createSceneSegments).toHaveBeenCalledWith('video.mp4', '/out', [0, 5.2, 12.8, 120], true, true)
+    })
+  })
 })
 
 describe('setupCli', () => {