chore(release): 0.4.0 [skip ci]

feat: deal with larger streams

.gitattributes

@@ -0,0 +1,2 @@
+*.mp3 binary
+*.mp4 binary

.vscode/launch.json

@@ -0,0 +1,27 @@
+{
+  "version": "0.2.0",
+  "configurations": [
+    {
+      "type": "coreclr",
+      "request": "launch",
+      "name": "Launch StreamShorts.Console",
+      "program": "${workspaceFolder}/src/StreamShorts.Console/bin/Debug/net9.0/win-x64/StreamShorts.Console.dll",
+      "args": [
+        "${input:filePath}"
+      ],
+      "cwd": "${workspaceFolder}/src/StreamShorts.Console",
+      "stopAtEntry": false,
+      "console": "integratedTerminal",
+      "preLaunchTask": "build",
+      "justMyCode": false
+    }
+  ],
+  "inputs": [
+    {
+      "id": "filePath",
+      "type": "promptString",
+      "description": "Enter the path to the video file",
+      "default": ""
+    }
+  ]
+}

.vscode/tasks.json

@@ -0,0 +1,17 @@
+{
+  "version": "2.0.0",
+  "tasks": [
+    {
+      "label": "build",
+      "command": "dotnet",
+      "type": "process",
+      "args": [
+        "build",
+        "${workspaceFolder}/StreamShorts.sln",
+        "/property:GenerateFullPaths=true",
+        "/consoleloggerparameters:NoSummary"
+      ],
+      "problemMatcher": "$msCompile"
+    }
+  ]
+}

src/StreamShorts.Console/CHANGELOG.md

@@ -2,6 +2,36 @@
 
 All notable changes to this project will be documented in this file. See [versionize](https://github.com/versionize/versionize) for commit guidelines.
 
+<a name="0.4.0"></a>
+## [0.4.0](https://www.github.com/StevanFreeborn/stream-shorts/releases/tag/v0.4.0) (2025-10-10)
+
+### Features
+
+* enable processing of large video files over 2GB ([e611522](https://www.github.com/StevanFreeborn/stream-shorts/commit/e611522c7bc724807ea39bdb5e6005b2deb911be))
+
+### Bug Fixes
+
+* add validation that stream is seekable ([401f03e](https://www.github.com/StevanFreeborn/stream-shorts/commit/401f03e2f0149b0f9d68df5d62fc3d5cccd3dc9e))
+* fix error messages and remove unnecessary null check and use input file name for audio output name ([a34ffe5](https://www.github.com/StevanFreeborn/stream-shorts/commit/a34ffe575b9e16e24d0b3d15d117d96f11a17d59))
+
+<a name="0.3.0"></a>
+## [0.3.0](https://www.github.com/StevanFreeborn/stream-shorts/releases/tag/v0.3.0) (2025-10-09)
+
+### Features
+
+* add configurable output directory with validation ([8632f88](https://www.github.com/StevanFreeborn/stream-shorts/commit/8632f88817c78663c632156a490eb118b802fef6))
+
+### Bug Fixes
+
+* use file system abstraction in base directory method. thanks copilot 🤖 ([6ebec7c](https://www.github.com/StevanFreeborn/stream-shorts/commit/6ebec7c2859200fd6c4374a84786c21dfa143171))
+
+<a name="0.2.0"></a>
+## [0.2.0](https://www.github.com/StevanFreeborn/stream-shorts/releases/tag/v0.2.0) (2025-08-21)
+
+### Features
+
+* display location of output with link inside panel ([57e95b2](https://www.github.com/StevanFreeborn/stream-shorts/commit/57e95b2ea19ea97019df70bd7a5414984faaa1c7))
+
 <a name="0.1.0"></a>
 ## [0.1.0](https://www.github.com/StevanFreeborn/stream-shorts/releases/tag/v0.1.0) (2025-08-21)
 

src/StreamShorts.Console/Commands/DefaultCommand.cs

@@ -10,7 +10,9 @@ internal sealed class DefaultCommand(
   ITranscriber transcriber,
   ITranscriptAnalyzer transcriptAnalyzer,
   IShortsCreator shortsCreator,
-  TimeProvider timeProvider
+  TimeProvider timeProvider,
+  IConfiguration appConfig,
+  ILogger<DefaultCommand> logger
 ) : AsyncCommand<DefaultCommand.Settings>
 {
   private readonly JsonSerializerOptions _jsonSerializerOptions = new()
@@ -26,6 +28,8 @@ internal sealed class DefaultCommand(
   private readonly ITranscriptAnalyzer _transcriptAnalyzer = transcriptAnalyzer ?? throw new ArgumentNullException(nameof(transcriptAnalyzer));
   private readonly IShortsCreator _shortsCreator = shortsCreator ?? throw new ArgumentNullException(nameof(shortsCreator));
   private readonly TimeProvider _timeProvider = timeProvider ?? throw new ArgumentNullException(nameof(timeProvider));
+  private readonly IConfiguration _appConfig = appConfig ?? throw new ArgumentNullException(nameof(appConfig));
+  private readonly ILogger<DefaultCommand> _logger = logger ?? throw new ArgumentNullException(nameof(logger));
 
   /// <summary>
   /// Represents the settings for the default command.
@@ -49,7 +53,7 @@ internal sealed class DefaultCommand(
 
     if (_fileSystem.File.Exists(settings.Stream) is false)
     {
-      return ValidationResult.Error($"The specified stream file '{settings.Stream}' does not exist.");
+      return ValidationResult.Error($"The specified stream file '{settings.Stream.EscapeMarkup()}' does not exist.");
     }
 
     var fileExtension = _fileSystem.Path.GetExtension(settings.Stream).ToUpperInvariant();
@@ -64,23 +68,29 @@ internal sealed class DefaultCommand(
 
   public override async Task<int> ExecuteAsync(CommandContext context, Settings settings)
   {
-    _console.MarkupLine($"[blue]Processing stream:[/] {settings.Stream}");
-    var videoStream = _fileSystem.File.OpenRead(settings.Stream);
+    _console.MarkupLine($"[blue]Processing stream:[/] {settings.Stream.EscapeMarkup()}");
+    var videoStream = (FileStream)_fileSystem.File.OpenRead(settings.Stream);
 
-    Stream? audioStream = null;
+    var now = _timeProvider.GetUtcNow();
+    var inputFileName = _fileSystem.Path.GetFileNameWithoutExtension(settings.Stream);
+    var baseDirectory = ValidateAndGetBaseOutputDirectory();
+    var artifactsOutputDirectory = $"{now:yyyy_MM_dd_HH_mm_ss}_{inputFileName}";
+    var outputDirectoryPath = _fileSystem.Path.Combine(baseDirectory, artifactsOutputDirectory);
+
+    _fileSystem.Directory.CreateDirectory(outputDirectoryPath);
+
+    using var audioStream = new FileStream(
+      _fileSystem.Path.Combine(outputDirectoryPath, $"{inputFileName}.mp3"),
+      FileMode.Create,
+      FileAccess.ReadWrite,
+      FileShare.ReadWrite,
+      4096,
+      FileOptions.Asynchronous
+    );
 
     await _console.Status()
       .Spinner(Spinner.Known.Dots)
-      .StartAsync("Extracting audio...", async _ =>
-      {
-        audioStream = await _audioExtractor.ExtractMp3FromMp4Async(videoStream);
-      });
-
-    if (audioStream is null)
-    {
-      _console.MarkupLine("[red]Failed[/] to extract audio from the stream.");
-      return (int)ExitCode.FailedToExtractAudio;
-    }
+      .StartAsync("Extracting audio...", async _ => await _audioExtractor.ExtractMp3FromMp4Async(videoStream, audioStream));
 
     _console.MarkupLine($"[blue]Audio extracted[/] [green]successfully![/]");
 
@@ -100,15 +110,6 @@ internal sealed class DefaultCommand(
 
     _console.MarkupLine($"[blue]Transcription completed[/] [green]successfully![/]");
 
-    var now = _timeProvider.GetUtcNow();
-    var inputFileName = _fileSystem.Path.GetFileNameWithoutExtension(settings.Stream);
-    var outputDirectoryPath = _fileSystem.Path.Combine(
-      AppContext.BaseDirectory,
-      $"{now:yyyy_MM_dd_HH_mm_ss}_{inputFileName}"
-    );
-
-    _fileSystem.Directory.CreateDirectory(outputDirectoryPath);
-
     await _fileSystem.File.WriteAllTextAsync(
       _fileSystem.Path.Combine(outputDirectoryPath, "transcription.txt"),
       string.Join(Environment.NewLine, transcriptionSegments)
@@ -118,10 +119,7 @@ internal sealed class DefaultCommand(
 
     await _console.Status()
       .Spinner(Spinner.Known.Dots)
-      .StartAsync("Analyzing transcript...", async _ =>
-      {
-        analysis = await _transcriptAnalyzer.AnalyzeAsync(transcriptionSegments);
-      });
+      .StartAsync("Analyzing transcript...", async _ => analysis = await _transcriptAnalyzer.AnalyzeAsync(transcriptionSegments));
 
     if (analysis is null)
     {
@@ -149,14 +147,53 @@ internal sealed class DefaultCommand(
         }
       });
 
-    _console.MarkupLine($"[blue]Shorts created[/] [green]successfully![/]");
+    var directoryUri = new Uri(outputDirectoryPath).AbsoluteUri;
+    var panel = new Panel($"[blue link={directoryUri}]{artifactsOutputDirectory.EscapeMarkup()}[/]")
+    {
+      Header = new PanelHeader($"[blue]Shorts created[/] [green]successfully![/]")
+    };
 
-    return 0;
+    _console.Write(panel);
+
+    return (int)ExitCode.SuccessFullyProcessedStream;
+  }
+
+  private string ValidateAndGetBaseOutputDirectory()
+  {
+    var baseDirectory = _appConfig.GetValue<string>("OutputDirectory");
+
+    if (string.IsNullOrWhiteSpace(baseDirectory))
+    {
+      return AppContext.BaseDirectory;
+    }
+
+    try
+    {
+      var fullPath = _fileSystem.Path.GetFullPath(baseDirectory);
+
+      if (_fileSystem.Directory.Exists(fullPath) is false)
+      {
+        _fileSystem.Directory.CreateDirectory(fullPath);
+      }
+
+      return fullPath;
+    }
+    catch (Exception ex) when (
+      ex is ArgumentException
+        or NotSupportedException
+        or PathTooLongException
+        or DirectoryNotFoundException
+        or UnauthorizedAccessException
+    )
+    {
+      _logger.LogWarning(ex, "The configured output directory '{BaseDirectory}' is invalid. Defaulting to application base directory.", baseDirectory);
+      return AppContext.BaseDirectory;
+    }
   }
 
   private enum ExitCode
   {
-    FailedToExtractAudio,
     FailedToAnalyzeTranscript,
+    SuccessFullyProcessedStream,
   }
 }

src/StreamShorts.Console/StreamShorts.Console.csproj

@@ -4,7 +4,7 @@
     <AssemblyTitle>StreamShorts.Console</AssemblyTitle>
     <Product>StreamShorts.Console</Product>
     <Description>A command-line interface for StreamShorts</Description>
-    <Version>0.1.0</Version>
+    <Version>0.4.0</Version>
     <Authors>Stevan Freeborn</Authors>
     <OutputType>Exe</OutputType>
     <PublishSingleFile>true</PublishSingleFile>

src/StreamShorts.Library/Media/Audio/AudioExtractor.cs

@@ -25,42 +25,41 @@ public sealed class AudioExtractor : IAudioExtractor
     _videoService = videoService ?? throw new ArgumentNullException(nameof(videoService), $"{nameof(videoService)} cannot be null");
   }
 
-  public async Task<Stream> ExtractMp3FromMp4Async(Stream video)
+  public async Task<Stream> ExtractMp3FromMp4Async(Stream video, Stream audio)
   {
     if (video is null)
     {
       throw new ArgumentNullException(nameof(video), "Video stream cannot be null");
     }
 
-    if (video.CanRead is false)
+    if (IsVideoStreamUsable(video) is false)
     {
-      throw new ArgumentException("Video stream must be readable", nameof(video));
+      throw new ArgumentException("Stream must be readable and seekable", nameof(video));
     }
 
-    if (video.CanSeek is false)
+    if (audio is null)
     {
-      throw new ArgumentException("Video stream must be seekable", nameof(video));
+      throw new ArgumentNullException(nameof(audio), "Audio stream cannot be null");
+    }
+
+    if (IsAudioStreamUsable(audio) is false)
+    {
+      throw new ArgumentException("Stream must be writable and seekable", nameof(audio));
     }
 
     var originalPosition = video.Position;
 
     try
     {
-      var mp3Stream = new MemoryStream();
-      using var mp4Stream = new MemoryStream();
-
-      await video.CopyToAsync(mp4Stream).ConfigureAwait(false);
-      mp4Stream.Position = 0;
-
-      var wasExtracted = await _videoService.ExtractAudioFromVideoAsync(mp4Stream, mp3Stream).ConfigureAwait(false);
+      var wasExtracted = await _videoService.ExtractAudioFromVideoAsync(video, audio).ConfigureAwait(false);
 
       if (wasExtracted is false)
       {
         throw new FailedAudioExtractionException("Failed to extract audio from the video stream.");
       }
 
-      mp3Stream.Position = 0;
-      return mp3Stream;
+      audio.Position = 0;
+      return audio;
     }
     catch (Exception e) when (e is not FailedAudioExtractionException)
     {
@@ -71,4 +70,14 @@ public sealed class AudioExtractor : IAudioExtractor
       video.Position = originalPosition;
     }
   }
+
+  private static bool IsVideoStreamUsable(Stream stream)
+  {
+    return stream.CanRead && stream.CanSeek;
+  }
+
+  private static bool IsAudioStreamUsable(Stream stream)
+  {
+    return stream.CanWrite && stream.CanSeek;
+  }
 }

src/StreamShorts.Library/Media/Audio/IAudioExtractor.cs

@@ -9,11 +9,15 @@ public interface IAudioExtractor
   /// Extracts MP3 audio from an MP4 video stream.
   /// </summary>
   /// <param name="video">The input video stream.</param>
+  /// <param name="audio">The output audio stream where the extracted MP3 will be written.</param>
   /// <returns>A stream containing the extracted MP3 audio.</returns>
   /// <exception cref="ArgumentNullException">Thrown when the video stream is null.</exception>
   /// <exception cref="ArgumentException">Thrown when the video stream is not readable.</exception>
   /// <exception cref="ArgumentException">Thrown when the video stream is not seekable.</exception>
+  /// <exception cref="ArgumentNullException">Thrown when the audio stream is null.</exception>
+  /// <exception cref="ArgumentException">Thrown when the audio stream is not writable.</exception>
+  /// <exception cref="ArgumentException">Thrown when the audio stream is not seekable.</exception>
   /// <exception cref="FailedAudioExtractionException">Thrown when the audio extraction fails.</exception>
   /// <remarks>The method will preserve the passed video stream's data and position.</remarks>
-  Task<Stream> ExtractMp3FromMp4Async(Stream video);
+  Task<Stream> ExtractMp3FromMp4Async(Stream video, Stream audio);
 }

src/StreamShorts.Library/Media/FFMpegService.cs

@@ -12,14 +12,17 @@ internal sealed class FFMpegService : IVideoService
 {
   public async Task<bool> ExtractAudioFromVideoAsync(Stream video, Stream audio)
   {
-    return await FFMpegArguments
-      .FromPipeInput(new StreamPipeSource(video))
-      .OutputToPipe(
-        new StreamPipeSink(audio),
-        static o => o.DisableChannel(Channel.Video).ForceFormat("mp3")
-      )
-      .ProcessAsynchronously()
-      .ConfigureAwait(false);
+    var inputArguments = video is FileStream videoFileStream
+      ? FFMpegArguments.FromFileInput(videoFileStream.Name)
+      : FFMpegArguments.FromPipeInput(new StreamPipeSource(video));
+
+    Action<FFMpegArgumentOptions> arguments = static o => o.DisableChannel(Channel.Video).ForceFormat("mp3");
+
+    var processor = audio is FileStream audioFileStream
+      ? inputArguments.OutputToFile(audioFileStream.Name, addArguments: arguments)
+      : inputArguments.OutputToPipe(new StreamPipeSink(audio), addArguments: arguments);
+
+    return await processor.ProcessAsynchronously().ConfigureAwait(false);
   }
 
   public async Task CreateClipFromVideoAsync(

src/StreamShorts.Library/Media/NAudioService.cs

@@ -1,4 +1,3 @@
-
 using NAudio.Wave;
 
 namespace StreamShorts.Library.Media;

tests/StreamShorts.Console.Tests/Unit/Commands/DefaultCommandTests.cs

@@ -0,0 +1,19 @@
+namespace StreamShorts.Console.Tests.Unit.Commands;
+
+using Spectre.Console;
+
+public class DefaultCommandTests
+{
+  [Theory]
+  [InlineData("file[with]brackets.mp4", "file[[with]]brackets.mp4")]
+  [InlineData("normal-file.mp4", "normal-file.mp4")]
+  [InlineData("file_with_underscores.mp4", "file_with_underscores.mp4")]
+  [InlineData("file with spaces.mp4", "file with spaces.mp4")]
+  [InlineData("[brackets].mp4", "[[brackets]].mp4")]
+  public void EscapeMarkup_WhenCalledWithVariousInputs_ItShouldProperlyEscapeSquareBrackets(string input, string expected)
+  {
+    var result = input.EscapeMarkup();
+
+    result.Should().Be(expected);
+  }
+}

tests/StreamShorts.Library.Tests/Integration/Media/Audio/AudioExtractorTests.cs

@@ -9,13 +9,15 @@ public class AudioExtractorTests
   {
     using var testVideo = TestData.GetTestVideo();
     using var extractedAudio = TestData.GetExtractedAudio();
+    using var audioStream = new MemoryStream();
 
-    var result = await _sut.ExtractMp3FromMp4Async(testVideo);
+    var result = await _sut.ExtractMp3FromMp4Async(testVideo, audioStream);
 
     var audioBytes = await ConvertStreamToBytesAsync(extractedAudio);
     var resultBytes = await ConvertStreamToBytesAsync(result);
 
     resultBytes.Should().Equal(audioBytes);
+    result.Should().BeSameAs(audioStream);
   }
 
   private static async Task<byte[]> ConvertStreamToBytesAsync(Stream stream)

tests/StreamShorts.Library.Tests/Unit/Media/Audio/AudioExtractorTests.cs

@@ -25,7 +25,7 @@ public class AudioExtractorTests
   [Fact]
   public async Task ExtractMp3FromMp4Async_WhenVideoIsNull_ItShouldThrow()
   {
-    var action = async () => await _sut.ExtractMp3FromMp4Async(null!);
+    var action = async () => await _sut.ExtractMp3FromMp4Async(null!, new MemoryStream());
 
     await action.Should().ThrowAsync<ArgumentNullException>();
   }
@@ -36,7 +36,7 @@ public class AudioExtractorTests
     var mockStream = new Mock<Stream>();
     mockStream.Setup(s => s.CanRead).Returns(false);
 
-    var action = async () => await _sut.ExtractMp3FromMp4Async(mockStream.Object);
+    var action = async () => await _sut.ExtractMp3FromMp4Async(mockStream.Object, new MemoryStream());
 
     await action.Should().ThrowAsync<ArgumentException>();
   }
@@ -48,7 +48,7 @@ public class AudioExtractorTests
     mockStream.Setup(s => s.CanRead).Returns(true);
     mockStream.Setup(s => s.CanSeek).Returns(false);
 
-    var action = async () => await _sut.ExtractMp3FromMp4Async(mockStream.Object);
+    var action = async () => await _sut.ExtractMp3FromMp4Async(mockStream.Object, new MemoryStream());
 
     await action.Should().ThrowAsync<ArgumentException>();
   }
@@ -69,7 +69,7 @@ public class AudioExtractorTests
       )
       .ThrowsAsync(new Exception());
 
-    var action = async () => await _sut.ExtractMp3FromMp4Async(mockStream.Object);
+    var action = async () => await _sut.ExtractMp3FromMp4Async(mockStream.Object, new MemoryStream());
 
     await action.Should().ThrowAsync<FailedAudioExtractionException>();
   }
@@ -90,7 +90,7 @@ public class AudioExtractorTests
       )
       .ReturnsAsync(false);
 
-    var action = async () => await _sut.ExtractMp3FromMp4Async(mockStream.Object);
+    var action = async () => await _sut.ExtractMp3FromMp4Async(mockStream.Object, new MemoryStream());
 
     await action.Should().ThrowAsync<FailedAudioExtractionException>();
   }
@@ -111,7 +111,7 @@ public class AudioExtractorTests
       )
       .ReturnsAsync(true);
 
-    var result = await _sut.ExtractMp3FromMp4Async(mockStream.Object);
+    var result = await _sut.ExtractMp3FromMp4Async(mockStream.Object, new MemoryStream());
 
     result.Should().BeAssignableTo<Stream>();
     result.Should().BeOfType<MemoryStream>();
@@ -137,7 +137,7 @@ public class AudioExtractorTests
       )
       .ReturnsAsync(true);
 
-    await _sut.ExtractMp3FromMp4Async(stream);
+    await _sut.ExtractMp3FromMp4Async(stream, new MemoryStream());
 
     stream.Position.Should().Be(positionToRead);
   }