@redaksjon/protokoll 0.4.3 → 1.0.0

package/dist/transcript.js

@@ -5,6 +5,8 @@ import path__default from 'node:path';
 import * as fs$1 from 'fs/promises';
 import OpenAI$1, { OpenAI } from 'openai';
 import ffmpeg from 'fluent-ffmpeg';
+import * as os from 'node:os';
+import os__default from 'node:os';
 import * as fs from 'node:fs';
 import { glob } from 'glob';
 import crypto from 'node:crypto';
@@ -13,12 +15,10 @@ import { htmlToText } from 'html-to-text';
 import { Command } from 'commander';
 import * as yaml from 'js-yaml';
 import { existsSync, statSync } from 'fs';
-import * as os from 'node:os';
-import os__default from 'node:os';
 import winston from 'winston';
 import { IterationStrategyFactory } from '@riotprompt/riotprompt';
 
-const VERSION = "0.4.3 (HEAD/94e6969 T:v0.4.3 2026-01-21 16:26:11 -0800) linux x64 v24.12.0";
+const VERSION = "1.0.0 (HEAD/9fe7b5f T:v1.0.0 2026-01-24 09:49:02 -0800) linux x64 v24.13.0";
 const PROGRAM_NAME = "protokoll";
 const DEFAULT_DIFF = true;
 const DEFAULT_LOG = false;
@@ -2950,6 +2950,120 @@ const create$h = (config) => {
   };
 };
 
+const ffprobeAsync = (filePath) => {
+  return new Promise((resolve, reject) => {
+    ffmpeg.ffprobe(filePath, (err, metadata) => {
+      if (err) return reject(err);
+      resolve(metadata);
+    });
+  });
+};
+const create$g = (logger) => {
+  const storage = create$w({ log: logger.debug });
+  const getAudioCreationTime = async (filePath) => {
+    try {
+      const metadata = await ffprobeAsync(filePath);
+      const formatTags = metadata?.format?.tags;
+      if (formatTags?.creation_time) {
+        logger.debug("Found creation_time in format tags: %s", formatTags.creation_time);
+        return new Date(formatTags.creation_time);
+      }
+      if (metadata?.streams?.length > 0) {
+        for (const stream of metadata.streams) {
+          if (stream.tags?.creation_time) {
+            logger.debug("Found creation_time in stream tags: %s", stream.tags.creation_time);
+            return new Date(stream.tags.creation_time);
+          }
+        }
+      }
+      logger.debug("No creation_time found in audio file metadata");
+      return null;
+    } catch (error) {
+      logger.error("Error extracting creation time from audio file: %s", error);
+      return null;
+    }
+  };
+  const getFileSize = async (filePath) => {
+    try {
+      return await storage.getFileSize(filePath);
+    } catch (error) {
+      logger.error("Error getting file size: %s", error);
+      throw new Error(`Failed to get file size for ${filePath}: ${error}`);
+    }
+  };
+  const splitAudioFile = async (filePath, outputDir, maxSizeBytes) => {
+    try {
+      const metadata = await ffprobeAsync(filePath);
+      const duration = parseFloat(metadata.format.duration);
+      const fileSize = await getFileSize(filePath);
+      const segmentCount = Math.ceil(fileSize / maxSizeBytes);
+      const segmentDuration = duration / segmentCount;
+      logger.debug(`Splitting ${filePath} (${fileSize} bytes) into ${segmentCount} segments of ~${segmentDuration} seconds each`);
+      await storage.createDirectory(outputDir);
+      const outputFiles = [];
+      const fileExt = path__default.extname(filePath);
+      const fileName = path__default.basename(filePath, fileExt);
+      const promises = [];
+      for (let i = 0; i < segmentCount; i++) {
+        const startTime = i * segmentDuration;
+        const outputPath = path__default.join(outputDir, `${fileName}_part${i + 1}${fileExt}`);
+        outputFiles.push(outputPath);
+        const promise = new Promise((resolve, reject) => {
+          ffmpeg(filePath).setStartTime(startTime).setDuration(segmentDuration).output(outputPath).on("end", () => {
+            logger.debug(`Created segment ${i + 1}/${segmentCount}: ${outputPath}`);
+            resolve();
+          }).on("error", (err) => {
+            logger.error(`Error creating segment ${i + 1}/${segmentCount}: ${err}`);
+            reject(err);
+          }).run();
+        });
+        promises.push(promise);
+      }
+      await Promise.all(promises);
+      return outputFiles;
+    } catch (error) {
+      logger.error("Error splitting audio file: %s", error);
+      throw new Error(`Failed to split audio file ${filePath}: ${error}`);
+    }
+  };
+  const convertToSupportedFormat = async (filePath, outputDir) => {
+    try {
+      const fileExt = path__default.extname(filePath).toLowerCase();
+      const supportedFormats = [".flac", ".m4a", ".mp3", ".mp4", ".mpeg", ".mpga", ".oga", ".ogg", ".wav", ".webm"];
+      if (supportedFormats.includes(fileExt)) {
+        logger.debug(`File ${filePath} is already in a supported format: ${fileExt}`);
+        return filePath;
+      }
+      logger.info(`Converting ${fileExt} file to mp3 for transcription...`);
+      const fileName = path__default.basename(filePath, fileExt);
+      const outputPath = path__default.join(outputDir, `${fileName}.mp3`);
+      if (await storage.exists(outputPath)) {
+        logger.debug(`Converted file already exists: ${outputPath}`);
+        return outputPath;
+      }
+      await storage.createDirectory(outputDir);
+      return new Promise((resolve, reject) => {
+        ffmpeg(filePath).toFormat("mp3").audioBitrate("128k").output(outputPath).on("end", () => {
+          logger.info(`Successfully converted to: ${outputPath}`);
+          resolve(outputPath);
+        }).on("error", (err) => {
+          logger.error(`Error converting audio file: ${err}`);
+          reject(new Error(`Failed to convert ${filePath} to mp3: ${err.message}`));
+        }).run();
+      });
+    } catch (error) {
+      logger.error("Error in convertToSupportedFormat: %s", error);
+      throw new Error(`Failed to convert audio file ${filePath}: ${error}`);
+    }
+  };
+  return {
+    getAudioCreationTime,
+    getFileSize,
+    splitAudioFile,
+    convertToSupportedFormat
+  };
+};
+
 const MODEL_CAPABILITIES = {
   "whisper-1": {
     supportsStreaming: false,
@@ -2974,9 +3088,10 @@ const MODEL_CAPABILITIES = {
   }
 };
 
-const create$g = (openai) => {
+const create$f = (openai) => {
   const logger = getLogger();
   const storage = create$w({ log: logger.debug });
+  const media = create$g(logger);
   const supportsStreaming = (model) => {
     return MODEL_CAPABILITIES[model]?.supportsStreaming ?? false;
   };
@@ -2986,7 +3101,10 @@ const create$g = (openai) => {
   const transcribe = async (request) => {
     const { audioFile, config } = request;
     logger.debug("Starting transcription", { model: config.model, file: audioFile });
-    const audioStream = await storage.readStream(audioFile);
+    const tempDir = path.join(os.tmpdir(), "protokoll-conversions");
+    const convertedAudioFile = await media.convertToSupportedFormat(audioFile, tempDir);
+    logger.debug(`Using audio file for transcription: ${convertedAudioFile}`);
+    const audioStream = await storage.readStream(convertedAudioFile);
     const startTime = Date.now();
     const response = await openai.audio.transcriptions.create({
       model: config.model,
@@ -3011,12 +3129,12 @@ const create$g = (openai) => {
   };
 };
 
-const create$f = (options = {}) => {
+const create$e = (options = {}) => {
   let service = null;
   const getService = () => {
     if (!service) {
       const openai = options.openaiClient ?? new OpenAI$1({ apiKey: options.apiKey });
-      service = create$g(openai);
+      service = create$f(openai);
     }
     return service;
   };
@@ -3041,7 +3159,7 @@ const create$f = (options = {}) => {
   };
 };
 
-const create$e = (config) => {
+const create$d = (config) => {
   const logger = getLogger();
   let client = null;
   const getClient = () => {
@@ -3270,8 +3388,8 @@ const getRecommendedStrategy = (transcriptLength, hasUnknownNames, complexity) =
   return "adaptive";
 };
 
-const create$d = (config) => {
-  const client = create$e(config);
+const create$c = (config) => {
+  const client = create$d(config);
   return {
     complete: (request) => client.complete(request),
     completeWithTools: (request) => client.completeWithTools(request),
@@ -3352,7 +3470,7 @@ function extractNameContext(transcript, name) {
   }
   return context;
 }
-const create$c = (ctx) => ({
+const create$b = (ctx) => ({
   name: "lookup_person",
   description: "Look up information about a person mentioned in the transcript. Use when you encounter a name that might need spelling verification or additional context.",
   parameters: {
@@ -3501,7 +3619,7 @@ function extractTermContext(transcript, term) {
   }
   return context;
 }
-const create$b = (ctx) => ({
+const create$a = (ctx) => ({
   name: "lookup_project",
   description: "Look up project information for routing and context. Use when you need to determine where this note should be filed.",
   parameters: {
@@ -3670,7 +3788,7 @@ const create$b = (ctx) => ({
   }
 });
 
-const create$a = (ctx) => ({
+const create$9 = (ctx) => ({
   name: "verify_spelling",
   description: "Request user verification for an unknown name or term. Use when you encounter something that needs human confirmation.",
   parameters: {
@@ -3717,7 +3835,7 @@ Please provide the correct spelling:`,
   }
 });
 
-const create$9 = (ctx) => ({
+const create$8 = (ctx) => ({
   name: "route_note",
   description: "Determine the destination for this note based on content analysis.",
   parameters: {
@@ -3760,7 +3878,7 @@ const create$9 = (ctx) => ({
   }
 });
 
-const create$8 = (_ctx) => ({
+const create$7 = (_ctx) => ({
   name: "store_context",
   description: "Store new context information for future use. Use when you learn something new that should be remembered.",
   parameters: {
@@ -3795,13 +3913,13 @@ const create$8 = (_ctx) => ({
   }
 });
 
-const create$7 = (ctx) => {
+const create$6 = (ctx) => {
   const tools = [
-    create$c(ctx),
     create$b(ctx),
     create$a(ctx),
     create$9(ctx),
-    create$8()
+    create$8(ctx),
+    create$7()
   ];
   const toolMap = new Map(tools.map((t) => [t.name, t]));
   return {
@@ -3845,9 +3963,9 @@ const cleanResponseContent = (content) => {
   }
   return cleaned.trim();
 };
-const create$6 = (reasoning, ctx) => {
+const create$5 = (reasoning, ctx) => {
   const logger = getLogger();
-  const registry = create$7(ctx);
+  const registry = create$6(ctx);
   const process = async (transcriptText) => {
     const state = {
       originalText: transcriptText,
@@ -4515,18 +4633,18 @@ CRITICAL: Your response must contain ONLY the corrected transcript text - absolu
   return { process };
 };
 
-const create$5 = (reasoning, toolContext) => {
-  const executor = create$6(reasoning, toolContext);
+const create$4 = (reasoning, toolContext) => {
+  const executor = create$5(reasoning, toolContext);
   return {
     process: (transcriptText) => executor.process(transcriptText),
     getAvailableTools: () => {
-      const registry = create$7(toolContext);
+      const registry = create$6(toolContext);
       return registry.getTools().map((t) => t.name);
     }
   };
 };
 
-const create$4 = (config) => {
+const create$3 = (config) => {
   const logger = getLogger();
   const storage = create$w({ log: logger.debug });
   const buildDirectoryPath = (date) => {
@@ -4623,7 +4741,7 @@ const create$4 = (config) => {
   };
 };
 
-const create$3 = async (config) => {
+const create$2 = async (config) => {
   const logger = getLogger();
   const currentWorkingDir = globalThis.process.cwd();
   logger.debug("Initializing intelligent transcription pipeline...");
@@ -4672,16 +4790,16 @@ const create$3 = async (config) => {
   if (reflection) {
     logger.debug("Self-reflection system enabled");
   }
-  const transcription = create$f({
+  const transcription = create$e({
     defaultModel: config.transcriptionModel
   });
   logger.debug("Transcription service initialized with model: %s", config.transcriptionModel);
-  const reasoning = create$d({
+  const reasoning = create$c({
     model: config.model,
     reasoningLevel: config.reasoningLevel
   });
   logger.debug("Reasoning system initialized with model: %s, reasoning level: %s", config.model, config.reasoningLevel || "medium");
-  const complete = config.processedDirectory ? create$4({
+  const complete = config.processedDirectory ? create$3({
     processedDirectory: config.processedDirectory,
     outputStructure: config.outputStructure,
     dryRun: config.dryRun
@@ -4800,7 +4918,7 @@ const create$3 = async (config) => {
         // Always pass interactive handler - it will handle enabled/disabled internally
         interactiveInstance: interactive
       };
-      const executor = create$5(reasoning, toolContext);
+      const executor = create$4(reasoning, toolContext);
       const agenticResult = await executor.process(state.rawTranscript || "");
       state.enhancedText = agenticResult.enhancedText;
       const toolsUsed = agenticResult.toolsUsed;
@@ -4982,91 +5100,8 @@ const create$3 = async (config) => {
   return { process: processInput };
 };
 
-const create$2 = async (config) => {
-  return create$3(config);
-};
-
-const ffprobeAsync = (filePath) => {
-  return new Promise((resolve, reject) => {
-    ffmpeg.ffprobe(filePath, (err, metadata) => {
-      if (err) return reject(err);
-      resolve(metadata);
-    });
-  });
-};
-const create$1 = (logger) => {
-  const storage = create$w({ log: logger.debug });
-  const getAudioCreationTime = async (filePath) => {
-    try {
-      const metadata = await ffprobeAsync(filePath);
-      const formatTags = metadata?.format?.tags;
-      if (formatTags?.creation_time) {
-        logger.debug("Found creation_time in format tags: %s", formatTags.creation_time);
-        return new Date(formatTags.creation_time);
-      }
-      if (metadata?.streams?.length > 0) {
-        for (const stream of metadata.streams) {
-          if (stream.tags?.creation_time) {
-            logger.debug("Found creation_time in stream tags: %s", stream.tags.creation_time);
-            return new Date(stream.tags.creation_time);
-          }
-        }
-      }
-      logger.debug("No creation_time found in audio file metadata");
-      return null;
-    } catch (error) {
-      logger.error("Error extracting creation time from audio file: %s", error);
-      return null;
-    }
-  };
-  const getFileSize = async (filePath) => {
-    try {
-      return await storage.getFileSize(filePath);
-    } catch (error) {
-      logger.error("Error getting file size: %s", error);
-      throw new Error(`Failed to get file size for ${filePath}: ${error}`);
-    }
-  };
-  const splitAudioFile = async (filePath, outputDir, maxSizeBytes) => {
-    try {
-      const metadata = await ffprobeAsync(filePath);
-      const duration = parseFloat(metadata.format.duration);
-      const fileSize = await getFileSize(filePath);
-      const segmentCount = Math.ceil(fileSize / maxSizeBytes);
-      const segmentDuration = duration / segmentCount;
-      logger.debug(`Splitting ${filePath} (${fileSize} bytes) into ${segmentCount} segments of ~${segmentDuration} seconds each`);
-      await storage.createDirectory(outputDir);
-      const outputFiles = [];
-      const fileExt = path__default.extname(filePath);
-      const fileName = path__default.basename(filePath, fileExt);
-      const promises = [];
-      for (let i = 0; i < segmentCount; i++) {
-        const startTime = i * segmentDuration;
-        const outputPath = path__default.join(outputDir, `${fileName}_part${i + 1}${fileExt}`);
-        outputFiles.push(outputPath);
-        const promise = new Promise((resolve, reject) => {
-          ffmpeg(filePath).setStartTime(startTime).setDuration(segmentDuration).output(outputPath).on("end", () => {
-            logger.debug(`Created segment ${i + 1}/${segmentCount}: ${outputPath}`);
-            resolve();
-          }).on("error", (err) => {
-            logger.error(`Error creating segment ${i + 1}/${segmentCount}: ${err}`);
-            reject(err);
-          }).run();
-        });
-        promises.push(promise);
-      }
-      await Promise.all(promises);
-      return outputFiles;
-    } catch (error) {
-      logger.error("Error splitting audio file: %s", error);
-      throw new Error(`Failed to split audio file ${filePath}: ${error}`);
-    }
-  };
-  return {
-    getAudioCreationTime,
-    getFileSize,
-    splitAudioFile
-  };
+const create$1 = async (config) => {
+  return create$2(config);
 };
 
 const create = (config) => {
@@ -5249,10 +5284,19 @@ Respond ONLY with valid JSON in this exact format:
     isAvailable
   };
 };
+const withProgress = async (message, operation, print) => {
+  print(`[${message}...]`);
+  try {
+    const result = await operation();
+    return result;
+  } finally {
+  }
+};
 
 const projectAssist = /*#__PURE__*/Object.freeze(/*#__PURE__*/Object.defineProperty({
     __proto__: null,
-    create
+    create,
+    withProgress
 }, Symbol.toStringTag, { value: 'Module' }));
 
 const print$1 = (text) => process.stdout.write(text + "\n");
@@ -6392,7 +6436,7 @@ const runFeedback = async (transcriptPath, options) => {
   }
   const transcriptContent = await fs$1.readFile(transcriptPath, "utf-8");
   const context = await create$u();
-  const reasoning = create$d({ model: options.model || DEFAULT_MODEL });
+  const reasoning = create$c({ model: options.model || DEFAULT_MODEL });
   const feedbackCtx = {
     transcriptPath,
     transcriptContent,
@@ -6798,5 +6842,5 @@ const registerTranscriptCommands = (program) => {
   });
 };
 
-export { ALLOWED_OUTPUT_FILENAME_OPTIONS as A, listTranscripts as B, DEFAULT_TEMP_DIRECTORY as C, DEFAULT_REASONING_LEVEL as D, create$p as E, create$d as F, processFeedback as G, applyChanges as H, combineTranscripts as I, editTranscript as J, parseTranscript as K, createCompletion as L, contentFetcher as M, projectAssist as N, PROGRAM_NAME as P, VERSION as V, PROTOKOLL_DEFAULTS as a, DEFAULT_MAX_AUDIO_SIZE as b, create$w as c, create$1 as d, DEFAULT_INTERMEDIATE_DIRECTORY as e, ALLOWED_OUTPUT_STRUCTURES as f, getLogger as g, ALLOWED_AUDIO_EXTENSIONS as h, DEFAULT_OUTPUT_DIRECTORY as i, DEFAULT_INPUT_DIRECTORY as j, DEFAULT_OUTPUT_FILENAME_OPTIONS as k, DEFAULT_OUTPUT_STRUCTURE as l, DEFAULT_AUDIO_EXTENSIONS as m, DEFAULT_TIMEZONE as n, DEFAULT_CONFIG_DIR as o, create$2 as p, create$u as q, create as r, setLogLevel as s, DEFAULT_CONTEXT_DIR_NAME as t, DEFAULT_CONTEXT_CONFIG_FILE_NAME as u, DEFAULT_MODEL as v, DEFAULT_TRANSCRIPTION_MODEL as w, registerActionCommands as x, registerFeedbackCommands as y, registerTranscriptCommands as z };
+export { ALLOWED_OUTPUT_FILENAME_OPTIONS as A, listTranscripts as B, DEFAULT_TEMP_DIRECTORY as C, DEFAULT_REASONING_LEVEL as D, create$p as E, create$c as F, processFeedback as G, applyChanges as H, combineTranscripts as I, editTranscript as J, parseTranscript as K, createCompletion as L, contentFetcher as M, projectAssist as N, PROGRAM_NAME as P, VERSION as V, PROTOKOLL_DEFAULTS as a, DEFAULT_MAX_AUDIO_SIZE as b, create$w as c, create$g as d, DEFAULT_INTERMEDIATE_DIRECTORY as e, ALLOWED_OUTPUT_STRUCTURES as f, getLogger as g, ALLOWED_AUDIO_EXTENSIONS as h, DEFAULT_OUTPUT_DIRECTORY as i, DEFAULT_INPUT_DIRECTORY as j, DEFAULT_OUTPUT_FILENAME_OPTIONS as k, DEFAULT_OUTPUT_STRUCTURE as l, DEFAULT_AUDIO_EXTENSIONS as m, DEFAULT_TIMEZONE as n, DEFAULT_CONFIG_DIR as o, create$1 as p, create$u as q, create as r, setLogLevel as s, DEFAULT_CONTEXT_DIR_NAME as t, DEFAULT_CONTEXT_CONFIG_FILE_NAME as u, DEFAULT_MODEL as v, DEFAULT_TRANSCRIPTION_MODEL as w, registerActionCommands as x, registerFeedbackCommands as y, registerTranscriptCommands as z };
 //# sourceMappingURL=transcript.js.map