@shaztech/video-cutter 1.0.0 → 1.1.1

package/README.md

@@ -1,6 +1,9 @@
 # Video Cutter
 
-A simple CLI tool to cut a video file into equal-length segments using ffmpeg.
+[![CI](https://github.com/shaztechio/video-cutter/actions/workflows/ci.yml/badge.svg)](https://github.com/shaztechio/video-cutter/actions/workflows/ci.yml)
+[![npm version](https://img.shields.io/npm/v/@shaztech/video-cutter.svg)](https://www.npmjs.com/package/@shaztech/video-cutter)
+
+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 +33,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 +68,31 @@ 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 `scdet` filter computes a per-frame difference score (0–100) representing how different each frame is from the previous one — essentially the percentage of maximum possible pixel change across the frame.
+
+- **Low threshold (e.g. 2–5):** Very sensitive — detects subtle transitions, fades, and gradual lighting changes. Produces many cuts, including false positives.
+- **Default threshold (10):** Catches hard cuts reliably with few false positives. ffmpeg's own docs suggest the sweet spot is 8–14.
+- **High threshold (e.g. 30–50):** Only detects dramatic, obvious scene changes. May miss some real cuts.
+- **100:** Would never trigger (nothing is ever 100% different).
+
+So for a cartoon with sharp hard cuts between scenes, the default of 10 should work well. If you're getting too many segments (spurious cuts on action frames), raise it to 20–30. If you're getting too few (missing real scene changes), lower it to 5–8.
+
+**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 +107,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.1",
   "type": "module",
   "description": "A CLI tool to cut videos into segments using ffmpeg",
   "main": "index.js",
@@ -35,13 +35,16 @@
     "eslint": "^8.57.1",
     "eslint-config-standard": "^17.1.0",
     "eslint-plugin-import": "^2.32.0",
-    "eslint-plugin-n": "^17.24.0",
-    "eslint-plugin-promise": "^7.2.1",
+    "eslint-plugin-n": "^16.6.2",
+    "eslint-plugin-promise": "^6.6.0",
     "jsdom": "^28.1.0",
     "vitest": "^4.1.0"
   },
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/shazron/video-cutter.git"
+    "url": "git+https://github.com/shaztechio/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/.claude/settings.local.json

@@ -1,8 +0,0 @@
-{
-  "permissions": {
-    "allow": [
-      "Bash(npm run:*)",
-      "Bash(npx vitest:*)"
-    ]
-  }
-}

package/.eslintrc.json

@@ -1,11 +0,0 @@
-{
-  "extends": "standard",
-  "env": {
-    "node": true,
-    "es6": true
-  },
-  "rules": {
-    "semi": ["error", "never"],
-    "quotes": ["error", "single"]
-  }
-}

package/tests/cli-direct.spec.js

@@ -1,113 +0,0 @@
-/*
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-// Tests that index.js calls setupCli() when invoked as the main entry point.
-// This file has its own module registry so vi.doMock works correctly.
-
-import { describe, it, expect, vi, afterEach } from 'vitest'
-import path from 'path'
-import { fileURLToPath } from 'url'
-
-describe('index.js invoked directly as main module', () => {
-  afterEach(() => vi.resetModules())
-
-  it('calls program.parse() when process.argv[1] matches the module path', async () => {
-    const parseMock = vi.fn()
-
-    vi.doMock('child_process', () => ({
-      execSync: vi.fn(), // does not throw → ffmpeg available
-      spawn: vi.fn()
-    }))
-    vi.doMock('../src/core.js', () => ({
-      getVideoDuration: vi.fn(),
-      createCountSegments: vi.fn(),
-      createTimeSegments: vi.fn()
-    }))
-    vi.doMock('commander', () => {
-      const mockProgram = {
-        name: vi.fn().mockReturnThis(),
-        description: vi.fn().mockReturnThis(),
-        version: vi.fn().mockReturnThis(),
-        requiredOption: vi.fn().mockReturnThis(),
-        addOption: vi.fn().mockReturnThis(),
-        option: vi.fn().mockReturnThis(),
-        action: vi.fn().mockReturnThis(),
-        parse: parseMock
-      }
-      return {
-        // eslint-disable-next-line prefer-arrow-callback
-        Command: vi.fn(function MockCommand () { return mockProgram }),
-        // eslint-disable-next-line prefer-arrow-callback
-        Option: vi.fn(function MockOption () { return { conflicts: vi.fn().mockReturnThis() } })
-      }
-    })
-
-    // Simulate running `node index.js` by setting argv[1] to the index.js path
-    const indexPath = path.resolve(fileURLToPath(new URL('../index.js', import.meta.url)))
-    const originalArgv1 = process.argv[1]
-    process.argv[1] = indexPath
-
-    try {
-      await import('../index.js')
-    } finally {
-      process.argv[1] = originalArgv1
-    }
-
-    expect(parseMock).toHaveBeenCalled()
-  })
-
-  it('does not call setupCli when process.argv[1] is empty (covers falsy argv branch)', async () => {
-    vi.doMock('child_process', () => ({
-      execSync: vi.fn(),
-      spawn: vi.fn()
-    }))
-    vi.doMock('../src/core.js', () => ({
-      getVideoDuration: vi.fn(),
-      createCountSegments: vi.fn(),
-      createTimeSegments: vi.fn()
-    }))
-    const parseMock = vi.fn()
-    vi.doMock('commander', () => {
-      const mockProgram = {
-        name: vi.fn().mockReturnThis(),
-        description: vi.fn().mockReturnThis(),
-        version: vi.fn().mockReturnThis(),
-        requiredOption: vi.fn().mockReturnThis(),
-        addOption: vi.fn().mockReturnThis(),
-        option: vi.fn().mockReturnThis(),
-        action: vi.fn().mockReturnThis(),
-        parse: parseMock
-      }
-      return {
-        // eslint-disable-next-line prefer-arrow-callback
-        Command: vi.fn(function MockCommand () { return mockProgram }),
-        // eslint-disable-next-line prefer-arrow-callback
-        Option: vi.fn(function MockOption () { return { conflicts: vi.fn().mockReturnThis() } })
-      }
-    })
-
-    // Empty argv[1] triggers the `? ... : ''` false branch in index.js
-    const originalArgv1 = process.argv[1]
-    process.argv[1] = ''
-
-    try {
-      await import('../index.js')
-    } finally {
-      process.argv[1] = originalArgv1
-    }
-
-    // setupCli is not called because mainModule ('') !== path to index.js
-    expect(parseMock).not.toHaveBeenCalled()
-  })
-})

package/tests/core.spec.js

@@ -1,201 +0,0 @@
-/*
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-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'
-
-vi.mock('child_process', () => ({
-  spawn: vi.fn()
-}))
-
-function createMockProcess ({ stdoutData = null, stderrData = null, exitCode = 0 } = {}) {
-  const proc = new EventEmitter()
-  proc.stdout = new EventEmitter()
-  proc.stderr = new EventEmitter()
-  setTimeout(() => {
-    if (stdoutData !== null) proc.stdout.emit('data', Buffer.from(stdoutData))
-    if (stderrData !== null) proc.stderr.emit('data', Buffer.from(stderrData))
-    proc.emit('close', exitCode)
-  }, 0)
-  return proc
-}
-
-describe('getVideoDuration', () => {
-  beforeEach(() => vi.clearAllMocks())
-  afterEach(() => vi.restoreAllMocks())
-
-  it('resolves with parsed duration on success', async () => {
-    vi.mocked(spawn).mockReturnValueOnce(createMockProcess({ stdoutData: '120.5\n' }))
-    const duration = await getVideoDuration('video.mp4')
-    expect(duration).toBe(120.5)
-  })
-
-  it('handles stderr data without error', async () => {
-    vi.mocked(spawn).mockReturnValueOnce(createMockProcess({ stdoutData: '90.0\n', stderrData: 'some warning' }))
-    const duration = await getVideoDuration('video.mp4')
-    expect(duration).toBe(90.0)
-  })
-
-  it('rejects on non-zero exit code', async () => {
-    vi.mocked(spawn).mockReturnValueOnce(createMockProcess({ exitCode: 1 }))
-    await expect(getVideoDuration('video.mp4')).rejects.toThrow('ffprobe exited with code 1')
-  })
-
-  it('rejects when output cannot be parsed as number', async () => {
-    vi.mocked(spawn).mockReturnValueOnce(createMockProcess({ stdoutData: 'invalid_output', exitCode: 0 }))
-    await expect(getVideoDuration('video.mp4')).rejects.toThrow('Could not parse duration')
-  })
-})
-
-describe('createSegment', () => {
-  beforeEach(() => vi.clearAllMocks())
-  afterEach(() => vi.restoreAllMocks())
-
-  it('creates segment using stream copy by default (reEncode=false)', async () => {
-    vi.mocked(spawn).mockReturnValueOnce(createMockProcess())
-    await expect(createSegment('video.mp4', 0, 60, 'out/seg.mp4', false)).resolves.toBeUndefined()
-    expect(spawn).toHaveBeenCalledWith('ffmpeg', expect.arrayContaining(['-c', 'copy']))
-  })
-
-  it('creates segment with re-encoding when reEncode=true', async () => {
-    vi.mocked(spawn).mockReturnValueOnce(createMockProcess())
-    await expect(createSegment('video.mp4', 0, 60, 'out/seg.mp4', true)).resolves.toBeUndefined()
-    expect(spawn).toHaveBeenCalledWith('ffmpeg', expect.arrayContaining(['-c:v', 'libx264']))
-  })
-
-  it('handles stdout and stderr data', async () => {
-    vi.mocked(spawn).mockReturnValueOnce(createMockProcess({ stdoutData: 'progress', stderrData: 'info' }))
-    await expect(createSegment('video.mp4', 0, 60, 'out/seg.mp4')).resolves.toBeUndefined()
-  })
-
-  it('rejects on non-zero exit code', async () => {
-    vi.mocked(spawn).mockReturnValueOnce(createMockProcess({ exitCode: 1 }))
-    await expect(createSegment('video.mp4', 0, 60, 'out/seg.mp4')).rejects.toThrow('ffmpeg exited with code 1')
-  })
-})
-
-describe('createCountSegments', () => {
-  beforeEach(() => {
-    vi.clearAllMocks()
-    vi.spyOn(console, 'log').mockImplementation(() => {})
-    vi.spyOn(console, 'warn').mockImplementation(() => {})
-    vi.spyOn(console, 'error').mockImplementation(() => {})
-  })
-  afterEach(() => vi.restoreAllMocks())
-
-  it('creates segments without verification', async () => {
-    vi.mocked(spawn)
-      .mockReturnValueOnce(createMockProcess())
-      .mockReturnValueOnce(createMockProcess())
-    await expect(createCountSegments('video.mp4', 120, 2, '/output')).resolves.toBeUndefined()
-    expect(spawn).toHaveBeenCalledTimes(2)
-  })
-
-  it('verifies valid segment durations within stream copy tolerance (1s)', async () => {
-    vi.mocked(spawn)
-      .mockReturnValueOnce(createMockProcess())
-      .mockReturnValueOnce(createMockProcess({ stdoutData: '120.0\n' }))
-    await expect(createCountSegments('video.mp4', 120, 1, '/output', true)).resolves.toBeUndefined()
-  })
-
-  it('warns when verified segment duration is outside tolerance', async () => {
-    vi.mocked(spawn)
-      .mockReturnValueOnce(createMockProcess())
-      .mockReturnValueOnce(createMockProcess({ stdoutData: '117.0\n' })) // 3s diff > 1s tolerance
-    await createCountSegments('video.mp4', 120, 1, '/output', true)
-    expect(console.warn).toHaveBeenCalled()
-  })
-
-  it('uses 0.1s tolerance when re-encoding and warns on invalid segments', async () => {
-    vi.mocked(spawn)
-      .mockReturnValueOnce(createMockProcess())
-      .mockReturnValueOnce(createMockProcess({ stdoutData: '119.5\n' })) // 0.5s diff > 0.1s tolerance
-    await createCountSegments('video.mp4', 120, 1, '/output', true, true)
-    expect(console.warn).toHaveBeenCalled()
-  })
-
-  it('logs success when verified segment is within re-encode tolerance', async () => {
-    vi.mocked(spawn)
-      .mockReturnValueOnce(createMockProcess())
-      .mockReturnValueOnce(createMockProcess({ stdoutData: '120.05\n' })) // 0.05s diff <= 0.1s tolerance
-    await createCountSegments('video.mp4', 120, 1, '/output', true, true)
-    expect(console.log).toHaveBeenCalledWith(expect.stringContaining('Verified'))
-  })
-
-  it('calls process.exit(1) when segment creation fails', async () => {
-    const exitSpy = vi.spyOn(process, 'exit').mockImplementation(() => { throw new Error('exit') })
-    vi.mocked(spawn).mockReturnValueOnce(createMockProcess({ exitCode: 1 }))
-    await expect(createCountSegments('video.mp4', 120, 1, '/output')).rejects.toThrow('exit')
-    expect(exitSpy).toHaveBeenCalledWith(1)
-  })
-})
-
-describe('createTimeSegments', () => {
-  beforeEach(() => {
-    vi.clearAllMocks()
-    vi.spyOn(console, 'log').mockImplementation(() => {})
-    vi.spyOn(console, 'warn').mockImplementation(() => {})
-    vi.spyOn(console, 'error').mockImplementation(() => {})
-  })
-  afterEach(() => vi.restoreAllMocks())
-
-  it('creates segments without verification', async () => {
-    vi.mocked(spawn)
-      .mockReturnValueOnce(createMockProcess())
-      .mockReturnValueOnce(createMockProcess())
-    await expect(createTimeSegments('video.mp4', 120, 60, '/output')).resolves.toBeUndefined()
-    expect(spawn).toHaveBeenCalledTimes(2)
-  })
-
-  it('verifies valid segment durations', async () => {
-    vi.mocked(spawn)
-      .mockReturnValueOnce(createMockProcess())
-      .mockReturnValueOnce(createMockProcess({ stdoutData: '60.0\n' }))
-    await expect(createTimeSegments('video.mp4', 60, 60, '/output', true)).resolves.toBeUndefined()
-  })
-
-  it('warns when verified segment duration is outside tolerance', async () => {
-    vi.mocked(spawn)
-      .mockReturnValueOnce(createMockProcess())
-      .mockReturnValueOnce(createMockProcess({ stdoutData: '57.0\n' })) // 3s diff > 1s tolerance
-    await createTimeSegments('video.mp4', 60, 60, '/output', true)
-    expect(console.warn).toHaveBeenCalled()
-  })
-
-  it('uses 0.1s tolerance when re-encoding and warns on invalid segments', async () => {
-    vi.mocked(spawn)
-      .mockReturnValueOnce(createMockProcess())
-      .mockReturnValueOnce(createMockProcess({ stdoutData: '59.5\n' })) // 0.5s diff > 0.1s tolerance
-    await createTimeSegments('video.mp4', 60, 60, '/output', true, true)
-    expect(console.warn).toHaveBeenCalled()
-  })
-
-  it('logs success when verified segment is within re-encode tolerance', async () => {
-    vi.mocked(spawn)
-      .mockReturnValueOnce(createMockProcess())
-      .mockReturnValueOnce(createMockProcess({ stdoutData: '60.05\n' })) // 0.05s diff <= 0.1s tolerance
-    await createTimeSegments('video.mp4', 60, 60, '/output', true, true)
-    expect(console.log).toHaveBeenCalledWith(expect.stringContaining('Verified'))
-  })
-
-  it('calls process.exit(1) when segment creation fails', async () => {
-    const exitSpy = vi.spyOn(process, 'exit').mockImplementation(() => { throw new Error('exit') })
-    vi.mocked(spawn).mockReturnValueOnce(createMockProcess({ exitCode: 1 }))
-    await expect(createTimeSegments('video.mp4', 60, 60, '/output')).rejects.toThrow('exit')
-    expect(exitSpy).toHaveBeenCalledWith(1)
-  })
-})

package/tests/ffmpeg-check.spec.js

@@ -1,63 +0,0 @@
-/*
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-// This file tests the module-level ffmpeg/ffprobe availability check in index.js.
-// It uses vi.doMock (not hoisted) so that the mock is applied before the dynamic import.
-
-import { describe, it, expect, vi } from 'vitest'
-
-describe('module-level ffmpeg/ffprobe check', () => {
-  it('exits with code 1 when ffmpeg is not installed', async () => {
-    vi.doMock('child_process', () => ({
-      // eslint-disable-next-line prefer-arrow-callback
-      execSync: vi.fn(function execSync () { throw new Error('command not found') }),
-      spawn: vi.fn()
-    }))
-    vi.doMock('../src/core.js', () => ({
-      getVideoDuration: vi.fn(),
-      createCountSegments: vi.fn(),
-      createTimeSegments: vi.fn()
-    }))
-    vi.doMock('commander', () => {
-      const mockProgram = {
-        name: vi.fn().mockReturnThis(),
-        description: vi.fn().mockReturnThis(),
-        version: vi.fn().mockReturnThis(),
-        requiredOption: vi.fn().mockReturnThis(),
-        addOption: vi.fn().mockReturnThis(),
-        option: vi.fn().mockReturnThis(),
-        action: vi.fn().mockReturnThis(),
-        parse: vi.fn()
-      }
-      return {
-        // eslint-disable-next-line prefer-arrow-callback
-        Command: vi.fn(function MockCommand () { return mockProgram }),
-        // eslint-disable-next-line prefer-arrow-callback
-        Option: vi.fn(function MockOption () { return { conflicts: vi.fn().mockReturnThis() } })
-      }
-    })
-
-    const exitSpy = vi.spyOn(process, 'exit').mockImplementation(() => { throw new Error('exit') })
-    vi.spyOn(console, 'error').mockImplementation(() => {})
-
-    try {
-      await import('../index.js')
-    } catch (e) {
-      // expected: process.exit() throws in test environment
-    }
-
-    expect(exitSpy).toHaveBeenCalledWith(1)
-    vi.restoreAllMocks()
-  })
-})

package/tests/index.spec.js

@@ -1,250 +0,0 @@
-/*
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-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 { processVideo, setupCli } from '../index.js'
-
-vi.mock('child_process', () => ({
-  execSync: vi.fn(), // doesn't throw = ffmpeg/ffprobe available
-  spawn: vi.fn()
-}))
-
-vi.mock('../src/core.js', () => ({
-  getVideoDuration: vi.fn(),
-  createCountSegments: vi.fn(),
-  createTimeSegments: vi.fn()
-}))
-
-vi.mock('commander', () => {
-  const mockProgram = {
-    name: vi.fn().mockReturnThis(),
-    description: vi.fn().mockReturnThis(),
-    version: vi.fn().mockReturnThis(),
-    requiredOption: vi.fn().mockReturnThis(),
-    addOption: vi.fn().mockReturnThis(),
-    option: vi.fn().mockReturnThis(),
-    action: vi.fn().mockReturnThis(),
-    parse: vi.fn()
-  }
-  // eslint-disable-next-line prefer-arrow-callback
-  const MockOption = vi.fn(function MockOption () { return { conflicts: vi.fn().mockReturnThis() } })
-  // eslint-disable-next-line prefer-arrow-callback
-  return { Command: vi.fn(function MockCommand () { return mockProgram }), Option: MockOption }
-})
-
-describe('processVideo', () => {
-  beforeEach(() => {
-    vi.clearAllMocks()
-    vi.spyOn(console, 'log').mockImplementation(() => {})
-    vi.spyOn(console, 'warn').mockImplementation(() => {})
-    vi.spyOn(console, 'error').mockImplementation(() => {})
-  })
-  afterEach(() => vi.restoreAllMocks())
-
-  it('exits when input file does not exist', async () => {
-    vi.spyOn(fs, 'existsSync').mockReturnValueOnce(false)
-    const exitSpy = vi.spyOn(process, 'exit').mockImplementation(() => { throw new Error('exit') })
-    await expect(processVideo({ input: 'missing.mp4', segments: 2, output: '/out' })).rejects.toThrow('exit')
-    expect(exitSpy).toHaveBeenCalledWith(1)
-  })
-
-  it('creates default output directory path when none provided', async () => {
-    vi.spyOn(fs, 'existsSync')
-      .mockReturnValueOnce(true) // input file exists
-      .mockReturnValueOnce(false) // output dir does not exist
-    vi.spyOn(fs, 'mkdirSync').mockImplementation(() => {})
-    vi.mocked(getVideoDuration).mockResolvedValue(120)
-    vi.mocked(createCountSegments).mockResolvedValue()
-
-    await processVideo({ input: 'video.mp4', segments: 2 })
-
-    expect(fs.mkdirSync).toHaveBeenCalledWith(expect.stringContaining('output'), { recursive: true })
-  })
-
-  it('creates output directory when it does not exist', async () => {
-    vi.spyOn(fs, 'existsSync')
-      .mockReturnValueOnce(true) // input file exists
-      .mockReturnValueOnce(false) // output dir does not exist
-    vi.spyOn(fs, 'mkdirSync').mockImplementation(() => {})
-    vi.mocked(getVideoDuration).mockResolvedValue(120)
-    vi.mocked(createCountSegments).mockResolvedValue()
-
-    await processVideo({ input: 'video.mp4', segments: 2, output: '/out' })
-
-    expect(fs.mkdirSync).toHaveBeenCalledWith('/out', { recursive: true })
-  })
-
-  it('exits when video duration cannot be determined (falsy)', async () => {
-    vi.spyOn(fs, 'existsSync').mockReturnValue(true)
-    vi.mocked(getVideoDuration).mockResolvedValue(0)
-    const exitSpy = vi.spyOn(process, 'exit').mockImplementation(() => { throw new Error('exit') })
-    await expect(processVideo({ input: 'video.mp4', segments: 2, output: '/out' })).rejects.toThrow('exit')
-    expect(exitSpy).toHaveBeenCalledWith(1)
-  })
-
-  it('exits when getVideoDuration throws', async () => {
-    vi.spyOn(fs, 'existsSync').mockReturnValue(true)
-    vi.mocked(getVideoDuration).mockRejectedValue(new Error('ffprobe failed'))
-    const exitSpy = vi.spyOn(process, 'exit').mockImplementation(() => { throw new Error('exit') })
-    await expect(processVideo({ input: 'video.mp4', segments: 2, output: '/out' })).rejects.toThrow('exit')
-    expect(exitSpy).toHaveBeenCalledWith(1)
-  })
-
-  describe('time-based segmentation (--duration)', () => {
-    it('warns about stream copy mode when not re-encoding', async () => {
-      vi.spyOn(fs, 'existsSync').mockReturnValue(true)
-      vi.mocked(getVideoDuration).mockResolvedValue(120)
-      vi.mocked(createTimeSegments).mockResolvedValue()
-
-      await processVideo({ input: 'video.mp4', duration: 60, output: '/out' })
-
-      expect(console.warn).toHaveBeenCalledWith(expect.stringContaining('stream copy mode'))
-      expect(createTimeSegments).toHaveBeenCalledWith('video.mp4', 120, 60, '/out', false, false)
-    })
-
-    it('does not warn when re-encoding', async () => {
-      vi.spyOn(fs, 'existsSync').mockReturnValue(true)
-      vi.mocked(getVideoDuration).mockResolvedValue(120)
-      vi.mocked(createTimeSegments).mockResolvedValue()
-
-      await processVideo({ input: 'video.mp4', duration: 60, output: '/out', reEncode: true })
-
-      expect(console.warn).not.toHaveBeenCalled()
-      expect(createTimeSegments).toHaveBeenCalledWith('video.mp4', 120, 60, '/out', false, true)
-    })
-
-    it('prompts user for short segments (<30s) and proceeds when confirmed', async () => {
-      vi.spyOn(fs, 'existsSync').mockReturnValue(true)
-      vi.mocked(getVideoDuration).mockResolvedValue(60)
-      vi.mocked(createTimeSegments).mockResolvedValue()
-      vi.spyOn(inquirer, 'prompt').mockResolvedValue({ confirm: true })
-
-      await processVideo({ input: 'video.mp4', duration: 10, output: '/out' })
-
-      expect(inquirer.prompt).toHaveBeenCalled()
-      expect(createTimeSegments).toHaveBeenCalled()
-    })
-
-    it('exits when user cancels short segment prompt', async () => {
-      vi.spyOn(fs, 'existsSync').mockReturnValue(true)
-      vi.mocked(getVideoDuration).mockResolvedValue(60)
-      vi.spyOn(inquirer, 'prompt').mockResolvedValue({ confirm: false })
-      const exitSpy = vi.spyOn(process, 'exit').mockImplementation(() => { throw new Error('exit') })
-
-      await expect(processVideo({ input: 'video.mp4', duration: 10, output: '/out' })).rejects.toThrow('exit')
-      expect(exitSpy).toHaveBeenCalledWith(0)
-    })
-  })
-
-  describe('count-based segmentation (--segments)', () => {
-    it('warns about stream copy mode when segments >= 30s', async () => {
-      vi.spyOn(fs, 'existsSync').mockReturnValue(true)
-      vi.mocked(getVideoDuration).mockResolvedValue(120)
-      vi.mocked(createCountSegments).mockResolvedValue()
-
-      await processVideo({ input: 'video.mp4', segments: 2, output: '/out' })
-
-      expect(console.warn).toHaveBeenCalledWith(expect.stringContaining('stream copy mode'))
-      expect(createCountSegments).toHaveBeenCalledWith('video.mp4', 120, 2, '/out', false, false)
-    })
-
-    it('does not warn when re-encoding with segments >= 30s', async () => {
-      vi.spyOn(fs, 'existsSync').mockReturnValue(true)
-      vi.mocked(getVideoDuration).mockResolvedValue(120)
-      vi.mocked(createCountSegments).mockResolvedValue()
-
-      await processVideo({ input: 'video.mp4', segments: 2, output: '/out', reEncode: true })
-
-      expect(console.warn).not.toHaveBeenCalled()
-    })
-
-    it('warns about stream copy mode when segments < 30s and not re-encoding', async () => {
-      vi.spyOn(fs, 'existsSync').mockReturnValue(true)
-      vi.mocked(getVideoDuration).mockResolvedValue(60)
-      vi.mocked(createCountSegments).mockResolvedValue()
-      vi.spyOn(inquirer, 'prompt').mockResolvedValue({ confirm: true })
-
-      await processVideo({ input: 'video.mp4', segments: 10, output: '/out' })
-
-      expect(console.warn).toHaveBeenCalledWith(expect.stringContaining('stream copy mode'))
-    })
-
-    it('does not warn when re-encoding with short count segments', async () => {
-      vi.spyOn(fs, 'existsSync').mockReturnValue(true)
-      vi.mocked(getVideoDuration).mockResolvedValue(60)
-      vi.mocked(createCountSegments).mockResolvedValue()
-      vi.spyOn(inquirer, 'prompt').mockResolvedValue({ confirm: true })
-
-      await processVideo({ input: 'video.mp4', segments: 10, output: '/out', reEncode: true })
-
-      expect(console.warn).not.toHaveBeenCalled()
-      expect(createCountSegments).toHaveBeenCalled()
-    })
-
-    it('prompts user for short segments and proceeds when confirmed', async () => {
-      vi.spyOn(fs, 'existsSync').mockReturnValue(true)
-      vi.mocked(getVideoDuration).mockResolvedValue(60)
-      vi.mocked(createCountSegments).mockResolvedValue()
-      vi.spyOn(inquirer, 'prompt').mockResolvedValue({ confirm: true })
-
-      await processVideo({ input: 'video.mp4', segments: 10, output: '/out' })
-
-      expect(inquirer.prompt).toHaveBeenCalled()
-      expect(createCountSegments).toHaveBeenCalled()
-    })
-
-    it('exits when user cancels short segment prompt', async () => {
-      vi.spyOn(fs, 'existsSync').mockReturnValue(true)
-      vi.mocked(getVideoDuration).mockResolvedValue(60)
-      vi.spyOn(inquirer, 'prompt').mockResolvedValue({ confirm: false })
-      const exitSpy = vi.spyOn(process, 'exit').mockImplementation(() => { throw new Error('exit') })
-
-      await expect(processVideo({ input: 'video.mp4', segments: 10, output: '/out' })).rejects.toThrow('exit')
-      expect(exitSpy).toHaveBeenCalledWith(0)
-    })
-
-    it('passes verify and reEncode flags correctly', async () => {
-      vi.spyOn(fs, 'existsSync').mockReturnValue(true)
-      vi.mocked(getVideoDuration).mockResolvedValue(120)
-      vi.mocked(createCountSegments).mockResolvedValue()
-
-      await processVideo({ input: 'video.mp4', segments: 2, output: '/out', verify: true, reEncode: true })
-
-      expect(createCountSegments).toHaveBeenCalledWith('video.mp4', 120, 2, '/out', true, true)
-    })
-  })
-})
-
-describe('setupCli', () => {
-  beforeEach(() => {
-    vi.clearAllMocks()
-    vi.spyOn(console, 'log').mockImplementation(() => {})
-  })
-  afterEach(() => vi.restoreAllMocks())
-
-  it('configures CLI with correct name, version, and options then calls parse', () => {
-    setupCli()
-    const program = vi.mocked(Command).mock.results[0].value
-    expect(program.name).toHaveBeenCalledWith('video-cutter')
-    expect(program.version).toHaveBeenCalledWith('1.0.0')
-    expect(program.requiredOption).toHaveBeenCalledWith('-i, --input <path>', expect.any(String))
-    expect(program.action).toHaveBeenCalledWith(processVideo)
-    expect(program.parse).toHaveBeenCalled()
-  })
-})

package/vitest.config.js

@@ -1,13 +0,0 @@
-import { defineConfig } from 'vitest/config'
-
-export default defineConfig({
-  test: {
-    globals: true,
-    environment: 'node',
-    coverage: {
-      provider: 'v8',
-      reporter: ['text', 'html', 'lcov'],
-      exclude: ['**/node_modules/**', '**/dist/**', '**/*.spec.js', 'vitest.config.js']
-    }
-  }
-})