@shaztech/video-cutter 1.1.0 → 1.1.1

package/README.md

@@ -1,5 +1,8 @@
 # Video Cutter
 
+[![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
@@ -79,15 +82,14 @@ This detects hard cuts between scenes and creates one segment per scene, named `
 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:
+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.
 
-| 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 |
+- **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).
 
-The default is **10**. Raise it if you are getting too many segments; lower it if real cuts are being missed.
+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.
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@shaztech/video-cutter",
-  "version": "1.1.0",
+  "version": "1.1.1",
   "type": "module",
   "description": "A CLI tool to cut videos into segments using ffmpeg",
   "main": "index.js",
@@ -35,14 +35,14 @@
     "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/.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/.github/workflows/ci.yml

@@ -1,19 +0,0 @@
-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

@@ -1,21 +0,0 @@
-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/tests/cli-direct.spec.js

@@ -1,117 +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(),
-      detectSceneChanges: vi.fn(),
-      createSceneSegments: 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(),
-      detectSceneChanges: vi.fn(),
-      createSceneSegments: 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,334 +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, detectSceneChanges, createSceneSegments } 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)
-  })
-})
-
-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

@@ -1,65 +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(),
-      detectSceneChanges: vi.fn(),
-      createSceneSegments: 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,331 +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, detectSceneChanges, createSceneSegments } 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(),
-  detectSceneChanges: vi.fn(),
-  createSceneSegments: 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('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', () => {
-  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']
-    }
-  }
-})