@shaztech/video-cutter 1.0.0

package/src/core.js

@@ -0,0 +1,251 @@
+/*
+ * 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.
+ */
+
+// Core video cutting logic functions
+import { spawn } from 'child_process'
+import path from 'path'
+import colors from 'colors'
+
+/**
+ * Get video duration using ffprobe
+ *
+ * @param {string} inputFile - Path to the input video file
+ * @returns {Promise<number>} - Video duration in seconds
+ */
+async function getVideoDuration (inputFile) {
+  return new Promise((resolve, reject) => {
+    const ffprobe = spawn('ffprobe', [
+      '-v', 'quiet',
+      '-show_entries', 'format=duration',
+      '-of', 'csv=p=0',
+      inputFile
+    ])
+
+    let output = ''
+    ffprobe.stdout.on('data', (data) => {
+      output += data.toString()
+    })
+
+    ffprobe.stderr.on('data', (data) => {
+      // Ignore stderr for this operation
+    })
+
+    ffprobe.on('close', (code) => {
+      if (code !== 0) {
+        reject(new Error(`ffprobe exited with code ${code}`))
+        return
+      }
+
+      const duration = parseFloat(output.trim())
+      if (isNaN(duration)) {
+        reject(new Error('Could not parse duration'))
+        return
+      }
+
+      resolve(duration)
+    })
+  })
+}
+
+/**
+ * Create a video segment using ffmpeg
+ *
+ * @param {string} inputFile - Path to the input video file
+ * @param {number} startTime - Start time of the segment in seconds
+ * @param {number} endTime - End time of the segment in seconds
+ * @param {string} outputFile - Path to save the output segment
+ * @param {boolean} reEncode - Whether to re-encode for exact duration
+ * @returns {Promise<void>}
+ */
+function createSegment (inputFile, startTime, endTime, outputFile, reEncode = false) {
+  return new Promise((resolve, reject) => {
+    console.log(`Creating segment: ${outputFile}`)
+
+    const args = [
+      '-ss', startTime.toString(),
+      '-t', (endTime - startTime).toString(),
+      '-i', inputFile
+    ]
+
+    if (reEncode) {
+      args.push(
+        '-c:v', 'libx264', // Re-encode to ensure exact duration
+        '-c:a', 'aac', // Re-encode audio
+        '-avoid_negative_ts', 'make_zero',
+        '-reset_timestamps', '1'
+      )
+    } else {
+      args.push(
+        '-c', 'copy', // Copy streams without re-encoding for speed
+        '-avoid_negative_ts', 'make_zero',
+        '-reset_timestamps', '1'
+      )
+    }
+
+    args.push(outputFile)
+
+    const ffmpeg = spawn('ffmpeg', args)
+
+    ffmpeg.stdout.on('data', (data) => {
+      // Log progress if needed
+    })
+
+    ffmpeg.stderr.on('data', (data) => {
+      // Handle errors
+    })
+
+    ffmpeg.on('close', (code) => {
+      if (code !== 0) {
+        reject(new Error(`ffmpeg exited with code ${code}`))
+      } else {
+        resolve()
+      }
+    })
+  })
+}
+
+/**
+ * Create video segments based on count
+ *
+ * @param {string} inputFile - Path to the input video file
+ * @param {number} duration - Total duration of the video
+ * @param {number} segmentCount - Number of segments to create
+ * @param {string} outputPath - Directory to save the segments
+ * @param {boolean} verifySegments - Whether to verify segment durations
+ * @param {boolean} reEncode - Whether to re-encode for exact duration
+ * @returns {Promise<void>}
+ */
+async function createCountSegments (inputFile, duration, segmentCount, outputPath, verifySegments = false, reEncode = false) {
+  // Calculate segment duration
+  const segmentDuration = duration / segmentCount
+
+  // Generate segments
+  const promises = []
+  for (let i = 0; i < segmentCount; i++) {
+    const startTime = i * segmentDuration
+    const endTime = Math.min((i + 1) * segmentDuration, duration)
+
+    const segmentFile = path.join(outputPath, `segment_${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!')
+
+      // Verify segments if requested
+      if (verifySegments) {
+        console.log('Verifying segment durations...')
+        for (let i = 0; i < segmentCount; i++) {
+          const startTime = i * segmentDuration
+          const endTime = Math.min((i + 1) * segmentDuration, duration)
+          const expectedDuration = endTime - startTime
+          const segmentFile = path.join(outputPath, `segment_${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 // Stricter tolerance when re-encoding
+          const isValid = difference <= tolerance
+          if (!isValid) {
+            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)
+    })
+}
+
+/**
+ * Create video segments based on duration
+ *
+ * @param {string} inputFile - Path to the input video file
+ * @param {number} videoDuration - Total duration of the video
+ * @param {number} segmentDuration - Duration of each segment in seconds
+ * @param {string} outputPath - Directory to save the segments
+ * @param {boolean} verifySegments - Whether to verify segment durations
+ * @param {boolean} reEncode - Whether to re-encode for exact duration
+ * @returns {Promise<void>}
+ */
+async function createTimeSegments (inputFile, videoDuration, segmentDuration, outputPath, verifySegments = false, reEncode = false) {
+  // Calculate number of segments needed
+  const segmentCount = Math.ceil(videoDuration / segmentDuration)
+
+  // Generate segments
+  const promises = []
+  for (let i = 0; i < segmentCount; i++) {
+    const startTime = i * segmentDuration
+    const endTime = Math.min((i + 1) * segmentDuration, videoDuration)
+
+    // Convert start time to HH-MM-SS format for filename
+    const hours = Math.floor(startTime / 3600)
+    const minutes = Math.floor((startTime % 3600) / 60)
+    const seconds = Math.floor(startTime % 60)
+
+    const padTime = (num) => String(num).padStart(2, '0')
+    const timeStr = `${padTime(hours)}-${padTime(minutes)}-${padTime(seconds)}`
+    const segmentFile = path.join(outputPath, `seg_${padTime(i + 1)}_${timeStr}.mp4`)
+
+    promises.push(createSegment(inputFile, startTime, endTime, segmentFile, reEncode))
+  }
+
+  return Promise.all(promises)
+    .then(async () => {
+      console.log('All segments created successfully!')
+
+      // Verify segments if requested
+      if (verifySegments) {
+        console.log('Verifying segment durations...')
+        for (let i = 0; i < segmentCount; i++) {
+          const startTime = i * segmentDuration
+          const endTime = Math.min((i + 1) * segmentDuration, videoDuration)
+          const expectedDuration = endTime - startTime
+
+          // Recalculate the time string for verification
+          const hours = Math.floor(startTime / 3600)
+          const minutes = Math.floor((startTime % 3600) / 60)
+          const seconds = Math.floor(startTime % 60)
+          const padTime = (num) => String(num).padStart(2, '0')
+          const timeStr = `${padTime(hours)}-${padTime(minutes)}-${padTime(seconds)}`
+          const segmentFile = path.join(outputPath, `seg_${padTime(i + 1)}_${timeStr}.mp4`)
+
+          const actualDuration = await getVideoDuration(segmentFile)
+          const difference = Math.abs(actualDuration - expectedDuration)
+          const tolerance = reEncode ? 0.1 : 1.0 // Stricter tolerance when re-encoding
+          const isValid = difference <= tolerance
+          if (!isValid) {
+            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
+}

package/tests/cli-direct.spec.js

@@ -0,0 +1,113 @@
+/*
+ * 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

@@ -0,0 +1,201 @@
+/*
+ * 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

@@ -0,0 +1,63 @@
+/*
+ * 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()
+  })
+})