additional test for commands.txt and fix for correct path in the ffmpegExtractor module

package.json

@@ -1,4 +1,5 @@
 {
+  "type": "module",
   "dependencies": {
     "cli-progress": "^3.12.0",
     "ffmpeg-static": "^5.2.0",
@@ -11,5 +12,4 @@
     "ts-node": "^10.9.2",
     "typescript": "^5.9.3"
   }
-}
+}
-

scripts/commands.txt

@@ -0,0 +1,5 @@
+npx ts-node ./extract.ts /Users/mikehughes/Downloads/Testvideo/Kurzgesagt.mov
+npx ts-node ./transcribe.ts ../storage/audio/Kurzgesagt.wav
+
+npx ts-node ./extract.ts /Users/mikehughes/Downloads/Testvideo/GitLabMeeting.mov
+npx ts-node ./transcribe.ts ../storage/audio/GitLabMeeting.wav

scripts/extract.ts

@@ -0,0 +1,23 @@
+#!/usr/bin/env ts-node
+
+import { extractAudioFromVideo } from "../services/modules/extraction/ffmpegExtractor.ts";
+
+const videoPath = process.argv[2];
+
+if (!videoPath) {
+  console.error("Usage: ts-node extractAudio.ts <videoPath>");
+  process.exit(1);
+}
+
+(async () => {
+  try {
+    console.log(`Extracting audio from: ${videoPath}`);
+
+    await extractAudioFromVideo(videoPath); // Call the extraction function (ffmpegExtractor.ts in services/modules/extraction)
+
+    console.log("Audio extraction completed successfully.");
+  } catch (err) {
+    console.error("Audio extraction failed:", err);
+    process.exit(1);
+  }
+})();

scripts/transcribe.ts

@@ -0,0 +1,18 @@
+import { whisperLocal } from "../services/modules/transcription/local/whisperLocal.ts";
+
+const audioPath = process.argv[2];
+if (!audioPath) {
+  console.error("Please provide an audio file path as argument.");
+  process.exit(1);
+}
+
+const whisper = new whisperLocal();
+
+(async () => {
+  try {
+    const text = await whisper.transcribe(audioPath);
+    console.log(text);
+  } catch (err) {
+    console.error("Transcription failed:", err);
+  }
+})();

services/modules/extraction/ffmpegExtractor.ts

@@ -3,32 +3,36 @@ import ffmpeg from 'fluent-ffmpeg';
 import path from 'path';
 import fs from 'fs';
 import cliProgress from 'cli-progress';
+import { fileURLToPath } from 'url';
 
 // Base code reference: https://docs.yemreak.com/arsiv/programming/extract-audio-from-video-with-typescript-and-ffmpeg
-// Test command: npx ts-node ffmpegExtractor.ts /path/to/video.mp4
+// Test command: npx ts-node ./extract.ts /path/to/video.mp4
 
 /**
  * Extracts audio from a video file and saves it as WAV.
  * @param videoFilePath Path to the input video file.
- * @param outputAudioPath Path where the output WAV audio will be saved.
  */
 
 // Ensure ffmpeg binary is available
 if (!ffmpegPath) {
-    throw new Error('FFmpeg binary not found!');
+  throw new Error('FFmpeg binary not found!');
 }
 ffmpeg.setFfmpegPath(ffmpegPath);
 
 // Ensure an input video path is provided via CLI
 if (process.argv.length < 3) {
-    console.error('Usage: ts-node ffmpegExtractor.ts <input-video-path>');
+  console.error('Usage: ts-node ./extract.ts <input-video-path>');
-    process.exit(1);
+  process.exit(1);
 }
 
-// Prepare output directory (always relative to project root)
+// Resolve __dirname equivalent in ESM
-const outputDir = path.join(process.cwd(), 'storage', 'audio');
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+// Prepare output directory (always storage/audio under project root)
+const outputDir = path.join(__dirname, '..', '..', '..', 'storage', 'audio');
 if (!fs.existsSync(outputDir)) {
-    fs.mkdirSync(outputDir, { recursive: true });
+  fs.mkdirSync(outputDir, { recursive: true });
 }
 
 // Derive input and output paths
@@ -38,10 +42,10 @@ const outputAudioPath = path.join(outputDir, `${inputVideoName}.wav`);
 
 // Initialize CLI progress bar
 const progressBar = new cliProgress.SingleBar({
-    format: 'Processing |{bar}| {percentage}% | {timemark}',
+  format: 'Processing |{bar}| {percentage}% | {timemark}',
-    barCompleteChar: '\u2588',
+  barCompleteChar: '\u2588',
-    barIncompleteChar: '\u2591',
+  barIncompleteChar: '\u2591',
-    hideCursor: true
+  hideCursor: true
 });
 
 /**
@@ -50,34 +54,37 @@ const progressBar = new cliProgress.SingleBar({
  * - Shows CLI progress bar
  * - Handles errors gracefully (without errors)
  */
-function extractAudioFromVideo(videoFilePath: string, outputAudioPath: string): Promise<void> {
+export function extractAudioFromVideo(videoFilePath: string): Promise<void> {
-    return new Promise((resolve, reject) => {
+  return new Promise((resolve, reject) => {
-        ffmpeg(videoFilePath)
+    ffmpeg(videoFilePath)
-            .outputFormat('wav') // Set output format to WAV
+      .outputFormat('wav')
-            .on('progress', (progress) => {
+      .audioCodec('pcm_s16le')
-                // Start progress bar if not already active
+      .audioChannels(1)
-                if (!progressBar.isActive) progressBar.start(100, 0, { timemark: '00:00:00' });
+      .audioFrequency(16000)
-                if (progress.percent) {
+      .on('progress', (progress) => {
-                    progressBar.update(progress.percent, { timemark: progress.timemark });
+        if (!progressBar.isActive) progressBar.start(100, 0, { timemark: '00:00:00' });
-                }
+        if (progress.percent) {
-            })
+          progressBar.update(progress.percent, { timemark: progress.timemark });
-            .on('end', () => {
+        }
-                // Finish progress bar
+      })
-                progressBar.update(100, { timemark: 'done' });
+      .on('end', () => {
-                progressBar.stop();
+        progressBar.update(100, { timemark: 'done' });
-                console.log(`Extraction completed: ${outputAudioPath}`);
+        progressBar.stop();
-                resolve();
+        console.log(`Extraction completed: ${outputAudioPath}`);
-            })
+        resolve();
-            .on('error', (err) => {
+      })
-                // Show extraction errors in a clear format
+      .on('error', (err) => {
-                console.error(`failed_audio_extraction: ${err.message}`);
+        progressBar.stop();
-                reject(err);
+        console.error(`failed_audio_extraction: ${err.message}`);
-            })
+        reject(err);
-            .save(outputAudioPath); // Save output file
+      })
-    });
+      .save(outputAudioPath);
+  });
 }
 
-// Run extraction
+// Run extraction if executed directly from CLI
-extractAudioFromVideo(inputVideoPath, outputAudioPath)
+if (import.meta.url === `file://${process.argv[1]}`) {
+  extractAudioFromVideo(inputVideoPath)
     .then(() => console.log('Audio extraction successful.'))
-    .catch((err) => console.error(err));
+    .catch((err) => console.error(err));
+}

services/modules/transcription/local/whisperLocal.ts

@@ -0,0 +1,55 @@
+import { exec } from "child_process"; // Node.js built-in module
+import path from "path"; // Path module
+import fs from "fs"; // File system module
+import { fileURLToPath } from "url"; // To handle __dirname in ES modules
+
+const __filename = fileURLToPath(import.meta.url); // Get current file path
+const __dirname = path.dirname(__filename); // Get current directory path
+const transcriptsDir = path.resolve(__dirname, "../../storage/transcriptions");
+
+
+export class whisperLocal { // is called by transcribe.ts
+  private whisperBinary: string; // Path to the whisper.cpp binary
+  private modelPath: string; // Path to the model file
+
+  constructor() {
+    this.whisperBinary = path.resolve(
+      __dirname,
+      "whisper.cpp/build/bin/whisper-cli" //Path to the compiled whisper binary
+    );
+
+    this.modelPath = path.resolve(
+      __dirname,
+      "whisper.cpp/models/ggml-base.en.bin" // Path to the English model file
+    );
+  }
+
+  async transcribe(audioPath: string): Promise<string> { //asyncronous function to transcribe audio
+    return new Promise((resolve, reject) => {
+        const transcriptsDir = path.resolve(__dirname, "../../../../storage/transcripts"); //storage directory for transcripts
+
+        if (!fs.existsSync(transcriptsDir)) { //if transcripts directory does not exist, create it
+            fs.mkdirSync(transcriptsDir, { recursive: true });
+        }
+
+        const outputBase = path.resolve( // Base path for output transcript files, name is same as audio file (video file)
+            transcriptsDir,
+            path.basename(audioPath, path.extname(audioPath))
+        );
+
+        const command = `"${this.whisperBinary}" -m "${this.modelPath}" -f "${audioPath}" -otxt -of "${outputBase}"`; // Command to execute whisper binary with model and audio file, outputting text file
+
+      exec(command, (error, stdout, stderr) => {
+        if (error) return reject(error);
+
+        const outputTxt = `${outputBase}.txt`;
+        if (fs.existsSync(outputTxt)) {
+          const transcript = fs.readFileSync(outputTxt, "utf8");
+          resolve(transcript);
+        } else {
+          reject(new Error("No transcript file found"));
+        }
+        });
+    });
+  }
+}