@redaksjon/protokoll-engine 0.1.1-dev.0

package/dist/index11.js

@@ -0,0 +1,22 @@
+import { create as create$2 } from './index39.js';
+import { create as create$1 } from './index40.js';
+
+const create = (config) => {
+  const collector = create$2();
+  const reporter = create$1(config);
+  return {
+    collector,
+    reporter,
+    generate: (audioFile, outputFile, conversationHistory, output) => reporter.generate(collector, audioFile, outputFile, conversationHistory, output),
+    save: (report, path) => reporter.save(report, path)
+  };
+};
+const DEFAULT_REFLECTION_CONFIG = {
+  enabled: false,
+  format: "markdown",
+  includeConversation: false,
+  includeOutput: true
+};
+
+export { DEFAULT_REFLECTION_CONFIG, create };
+//# sourceMappingURL=index11.js.map

package/dist/index11.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index11.js","sources":["../src/reflection/index.ts"],"sourcesContent":["/**\n * Self-Reflection System\n *\n * Main entry point for the self-reflection system. Provides metrics collection\n * and report generation for transcription quality analysis.\n */\n\nimport { ReflectionConfig, ReflectionReport } from './types';\nimport * as Collector from './collector';\nimport * as Reporter from './reporter';\n\nexport interface ReflectionInstance {\n    collector: Collector.CollectorInstance;\n    reporter: Reporter.ReporterInstance;\n    generate(\n        audioFile: string,\n        outputFile: string,\n        conversationHistory?: unknown[],\n        output?: string\n    ): ReflectionReport;\n    save(report: ReflectionReport, path: string): Promise<void>;\n}\n\nexport const create = (config: ReflectionConfig): ReflectionInstance => {\n    const collector = Collector.create();\n    const reporter = Reporter.create(config);\n  \n    return {\n        collector,\n        reporter,\n        generate: (audioFile, outputFile, conversationHistory, output) => \n            reporter.generate(collector, audioFile, outputFile, conversationHistory, output),\n        save: (report, path) => reporter.save(report, path),\n    };\n};\n\nexport const DEFAULT_REFLECTION_CONFIG: ReflectionConfig = {\n    enabled: false,\n    format: 'markdown',\n    includeConversation: false,\n    includeOutput: true,\n};\n\n// Re-export types\nexport * from './types';\n\n"],"names":["Collector.create","Reporter.create"],"mappings":";;;AAuBO,MAAM,MAAA,GAAS,CAAC,MAAA,KAAiD;AACpE,EAAA,MAAM,SAAA,GAAYA,QAAU,EAAO;AACnC,EAAA,MAAM,QAAA,GAAWC,QAAS,CAAO,MAAM,CAAA;AAEvC,EAAA,OAAO;AAAA,IACH,SAAA;AAAA,IACA,QAAA;AAAA,IACA,QAAA,EAAU,CAAC,SAAA,EAAW,UAAA,EAAY,mBAAA,EAAqB,MAAA,KACnD,QAAA,CAAS,QAAA,CAAS,SAAA,EAAW,SAAA,EAAW,UAAA,EAAY,mBAAA,EAAqB,MAAM,CAAA;AAAA,IACnF,MAAM,CAAC,MAAA,EAAQ,SAAS,QAAA,CAAS,IAAA,CAAK,QAAQ,IAAI;AAAA,GACtD;AACJ;AAEO,MAAM,yBAAA,GAA8C;AAAA,EACvD,OAAA,EAAS,KAAA;AAAA,EACT,MAAA,EAAQ,UAAA;AAAA,EACR,mBAAA,EAAqB,KAAA;AAAA,EACrB,aAAA,EAAe;AACnB;;;;"}

package/dist/index12.js

@@ -0,0 +1,125 @@
+import * as fs from 'node:fs';
+import { glob } from 'glob';
+import path__default from 'node:path';
+import crypto from 'node:crypto';
+
+const create = (params) => {
+  const log = params.log || console.log;
+  const exists = async (path2) => {
+    try {
+      await fs.promises.stat(path2);
+      return true;
+    } catch (error) {
+      return false;
+    }
+  };
+  const isDirectory = async (path2) => {
+    const stats = await fs.promises.stat(path2);
+    if (!stats.isDirectory()) {
+      log(`${path2} is not a directory`);
+      return false;
+    }
+    return true;
+  };
+  const isFile = async (path2) => {
+    const stats = await fs.promises.stat(path2);
+    if (!stats.isFile()) {
+      log(`${path2} is not a file`);
+      return false;
+    }
+    return true;
+  };
+  const isReadable = async (path2) => {
+    try {
+      await fs.promises.access(path2, fs.constants.R_OK);
+    } catch (error) {
+      log(`${path2} is not readable: %s %s`, error.message, error.stack);
+      return false;
+    }
+    return true;
+  };
+  const isWritable = async (path2) => {
+    try {
+      await fs.promises.access(path2, fs.constants.W_OK);
+    } catch (error) {
+      log(`${path2} is not writable: %s %s`, error.message, error.stack);
+      return false;
+    }
+    return true;
+  };
+  const isFileReadable = async (path2) => {
+    return await exists(path2) && await isFile(path2) && await isReadable(path2);
+  };
+  const isDirectoryWritable = async (path2) => {
+    return await exists(path2) && await isDirectory(path2) && await isWritable(path2);
+  };
+  const isDirectoryReadable = async (path2) => {
+    return await exists(path2) && await isDirectory(path2) && await isReadable(path2);
+  };
+  const createDirectory = async (path2) => {
+    try {
+      await fs.promises.mkdir(path2, { recursive: true });
+    } catch (mkdirError) {
+      throw new Error(`Failed to create output directory ${path2}: ${mkdirError.message} ${mkdirError.stack}`);
+    }
+  };
+  const readFile = async (path2, encoding) => {
+    return await fs.promises.readFile(path2, { encoding });
+  };
+  const writeFile = async (path2, data, encoding) => {
+    await fs.promises.writeFile(path2, data, { encoding });
+  };
+  const forEachFileIn = async (directory, callback, options = { pattern: "*.*" }) => {
+    try {
+      const files = await glob(options.pattern, { cwd: directory, nodir: true });
+      for (const file of files) {
+        await callback(path__default.join(directory, file));
+      }
+    } catch (err) {
+      throw new Error(`Failed to glob pattern ${options.pattern} in ${directory}: ${err.message}`);
+    }
+  };
+  const readStream = async (path2) => {
+    return fs.createReadStream(path2);
+  };
+  const hashFile = async (path2, length) => {
+    const file = await readFile(path2, "utf8");
+    return crypto.createHash("sha256").update(file).digest("hex").slice(0, length);
+  };
+  const listFiles = async (directory) => {
+    return await fs.promises.readdir(directory);
+  };
+  const deleteFile = async (path2) => {
+    await fs.promises.unlink(path2);
+  };
+  const deleteDirectory = async (path2) => {
+    await fs.promises.rm(path2, { recursive: true, force: true });
+  };
+  const getFileSize = async (path2) => {
+    const stats = await fs.promises.stat(path2);
+    return stats.size;
+  };
+  return {
+    exists,
+    isDirectory,
+    isFile,
+    isReadable,
+    isWritable,
+    isFileReadable,
+    isDirectoryWritable,
+    isDirectoryReadable,
+    createDirectory,
+    readFile,
+    readStream,
+    writeFile,
+    forEachFileIn,
+    hashFile,
+    listFiles,
+    deleteFile,
+    deleteDirectory,
+    getFileSize
+  };
+};
+
+export { create };
+//# sourceMappingURL=index12.js.map

package/dist/index12.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index12.js","sources":["../src/util/storage.ts"],"sourcesContent":["// eslint-disable-next-line no-restricted-imports\nimport * as fs from 'node:fs';\nimport { glob } from 'glob';\nimport path from 'node:path';\nimport crypto from 'node:crypto';\n/**\n * This module exists to isolate filesystem operations from the rest of the codebase.\n * This makes testing easier by avoiding direct fs mocking in jest configuration.\n * \n * Additionally, abstracting storage operations allows for future flexibility - \n * this export utility may need to work with storage systems other than the local filesystem\n * (e.g. S3, Google Cloud Storage, etc).\n */\n\nexport interface Utility {\n    exists: (path: string) => Promise<boolean>;\n    isDirectory: (path: string) => Promise<boolean>;\n    isFile: (path: string) => Promise<boolean>;\n    isReadable: (path: string) => Promise<boolean>;\n    isWritable: (path: string) => Promise<boolean>;\n    isFileReadable: (path: string) => Promise<boolean>;\n    isDirectoryWritable: (path: string) => Promise<boolean>;\n    isDirectoryReadable: (path: string) => Promise<boolean>;\n    createDirectory: (path: string) => Promise<void>;\n    readFile: (path: string, encoding: string) => Promise<string>;\n    readStream: (path: string) => Promise<fs.ReadStream>;\n    writeFile: (path: string, data: string | Buffer, encoding: string) => Promise<void>;\n    forEachFileIn: (directory: string, callback: (path: string) => Promise<void>, options?: { pattern: string }) => Promise<void>;\n    hashFile: (path: string, length: number) => Promise<string>;\n    listFiles: (directory: string) => Promise<string[]>;\n    deleteFile: (path: string) => Promise<void>;\n    deleteDirectory: (path: string) => Promise<void>;\n    getFileSize: (path: string) => Promise<number>;\n}\n\nexport const create = (params: { log?: (message: string, ...args: any[]) => void }): Utility => {\n\n    // eslint-disable-next-line no-console\n    const log = params.log || console.log;\n\n    const exists = async (path: string): Promise<boolean> => {\n        try {\n            await fs.promises.stat(path);\n            return true;\n            // eslint-disable-next-line @typescript-eslint/no-unused-vars\n        } catch (error: any) {\n            return false;\n        }\n    }\n\n    const isDirectory = async (path: string): Promise<boolean> => {\n        const stats = await fs.promises.stat(path);\n        if (!stats.isDirectory()) {\n            log(`${path} is not a directory`);\n            return false;\n        }\n        return true;\n    }\n\n    const isFile = async (path: string): Promise<boolean> => {\n        const stats = await fs.promises.stat(path);\n        if (!stats.isFile()) {\n            log(`${path} is not a file`);\n            return false;\n        }\n        return true;\n    }\n\n    const isReadable = async (path: string): Promise<boolean> => {\n        try {\n            await fs.promises.access(path, fs.constants.R_OK);\n        } catch (error: any) {\n            log(`${path} is not readable: %s %s`, error.message, error.stack);\n            return false;\n        }\n        return true;\n    }\n\n    const isWritable = async (path: string): Promise<boolean> => {\n        try {\n            await fs.promises.access(path, fs.constants.W_OK);\n        } catch (error: any) {\n            log(`${path} is not writable: %s %s`, error.message, error.stack);\n            return false;\n        }\n        return true;\n    }\n\n    const isFileReadable = async (path: string): Promise<boolean> => {\n        return await exists(path) && await isFile(path) && await isReadable(path);\n    }\n\n    const isDirectoryWritable = async (path: string): Promise<boolean> => {\n        return await exists(path) && await isDirectory(path) && await isWritable(path);\n    }\n\n    const isDirectoryReadable = async (path: string): Promise<boolean> => {\n        return await exists(path) && await isDirectory(path) && await isReadable(path);\n    }\n\n    const createDirectory = async (path: string): Promise<void> => {\n        try {\n            await fs.promises.mkdir(path, { recursive: true });\n        } catch (mkdirError: any) {\n            throw new Error(`Failed to create output directory ${path}: ${mkdirError.message} ${mkdirError.stack}`);\n        }\n    }\n\n    const readFile = async (path: string, encoding: string): Promise<string> => {\n        return await fs.promises.readFile(path, { encoding: encoding as BufferEncoding });\n    }\n\n    const writeFile = async (path: string, data: string | Buffer, encoding: string): Promise<void> => {\n        await fs.promises.writeFile(path, data, { encoding: encoding as BufferEncoding });\n    }\n\n    const forEachFileIn = async (directory: string, callback: (file: string) => Promise<void>, options: { pattern: string | string[] } = { pattern: '*.*' }): Promise<void> => {\n        try {\n            const files = await glob(options.pattern, { cwd: directory, nodir: true });\n            for (const file of files) {\n                await callback(path.join(directory, file));\n            }\n        } catch (err: any) {\n            throw new Error(`Failed to glob pattern ${options.pattern} in ${directory}: ${err.message}`);\n        }\n    }\n\n    const readStream = async (path: string): Promise<fs.ReadStream> => {\n        return fs.createReadStream(path);\n    }\n\n    const hashFile = async (path: string, length: number): Promise<string> => {\n        const file = await readFile(path, 'utf8');\n        return crypto.createHash('sha256').update(file).digest('hex').slice(0, length);\n    }\n\n    const listFiles = async (directory: string): Promise<string[]> => {\n        return await fs.promises.readdir(directory);\n    }\n\n    const deleteFile = async (path: string): Promise<void> => {\n        await fs.promises.unlink(path);\n    }\n\n    const deleteDirectory = async (path: string): Promise<void> => {\n        await fs.promises.rm(path, { recursive: true, force: true });\n    }\n\n    const getFileSize = async (path: string): Promise<number> => {\n        const stats = await fs.promises.stat(path);\n        return stats.size;\n    }\n\n    return {\n        exists,\n        isDirectory,\n        isFile,\n        isReadable,\n        isWritable,\n        isFileReadable,\n        isDirectoryWritable,\n        isDirectoryReadable,\n        createDirectory,\n        readFile,\n        readStream,\n        writeFile,\n        forEachFileIn,\n        hashFile,\n        listFiles,\n        deleteFile,\n        deleteDirectory,\n        getFileSize,\n    };\n}"],"names":["path"],"mappings":"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"}

package/dist/index13.js

@@ -0,0 +1,124 @@
+import ffmpeg from 'fluent-ffmpeg';
+import path__default from 'node:path';
+import { create as create$1 } from './index12.js';
+
+const ffprobeAsync = (filePath) => {
+  return new Promise((resolve, reject) => {
+    ffmpeg.ffprobe(filePath, (err, metadata) => {
+      if (err) return reject(err);
+      resolve(metadata);
+    });
+  });
+};
+const create = (logger) => {
+  const storage$1 = create$1({ 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$1.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$1.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, forceConversion = false) => {
+    try {
+      const fileExt = path__default.extname(filePath).toLowerCase();
+      const supportedFormats = [".flac", ".m4a", ".mp3", ".mp4", ".mpeg", ".mpga", ".oga", ".ogg", ".wav", ".webm"];
+      if (supportedFormats.includes(fileExt) && !forceConversion) {
+        logger.debug(`File ${filePath} is already in a supported format: ${fileExt}`);
+        return filePath;
+      }
+      if (forceConversion && fileExt === ".mp3") {
+        logger.debug(`File ${filePath} is already MP3 (compressed format)`);
+        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$1.exists(outputPath)) {
+        logger.debug(`Converted file already exists: ${outputPath}`);
+        return outputPath;
+      }
+      await storage$1.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
+  };
+};
+
+export { create };
+//# sourceMappingURL=index13.js.map

package/dist/index13.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index13.js","sources":["../src/util/media.ts"],"sourcesContent":["import ffmpeg from 'fluent-ffmpeg';\nimport { Logger } from 'winston';\nimport path from 'node:path';\nimport * as Storage from '@/util/storage';\n\nexport interface Media {\n    getAudioCreationTime: (filePath: string) => Promise<Date | null>;\n    getFileSize: (filePath: string) => Promise<number>;\n    splitAudioFile: (filePath: string, outputDir: string, maxSizeBytes: number) => Promise<string[]>;\n    convertToSupportedFormat: (filePath: string, outputDir: string, forceConversion?: boolean) => Promise<string>;\n}\n\nconst ffprobeAsync = (filePath: string): Promise<any> => {\n    return new Promise((resolve, reject) => {\n        ffmpeg.ffprobe(filePath, (err, metadata) => {\n            if (err) return reject(err);\n            resolve(metadata);\n        });\n    });\n};\n\n\nexport const create = (logger: Logger): Media => {\n    const storage = Storage.create({ log: logger.debug });\n\n    // Extract creation time from audio file using ffmpeg\n    const getAudioCreationTime = async (filePath: string): Promise<Date | null> => {\n        try {\n            const metadata = await ffprobeAsync(filePath);\n\n            // Look for creation_time in format tags\n            const formatTags = metadata?.format?.tags;\n            if (formatTags?.creation_time) {\n                logger.debug('Found creation_time in format tags: %s', formatTags.creation_time);\n                return new Date(formatTags.creation_time);\n            }\n\n            // Check for creation_time in stream tags as fallback\n            if (metadata?.streams?.length > 0) {\n                for (const stream of metadata.streams) {\n                    if (stream.tags?.creation_time) {\n                        logger.debug('Found creation_time in stream tags: %s', stream.tags.creation_time);\n                        return new Date(stream.tags.creation_time);\n                    }\n                }\n            }\n\n            logger.debug('No creation_time found in audio file metadata');\n            return null;\n        } catch (error) {\n            logger.error('Error extracting creation time from audio file: %s', error);\n            return null;\n        }\n    };\n\n    // Get file size in bytes\n    const getFileSize = async (filePath: string): Promise<number> => {\n        try {\n            return await storage.getFileSize(filePath);\n        } catch (error) {\n            logger.error('Error getting file size: %s', error);\n            throw new Error(`Failed to get file size for ${filePath}: ${error}`);\n        }\n    };\n\n    // Split large audio file into smaller chunks\n    const splitAudioFile = async (filePath: string, outputDir: string, maxSizeBytes: number): Promise<string[]> => {\n        try {\n            const metadata = await ffprobeAsync(filePath);\n            const duration = parseFloat(metadata.format.duration);\n\n            // Calculate how many segments we need based on file size and max size\n            const fileSize = await getFileSize(filePath);\n            const segmentCount = Math.ceil(fileSize / maxSizeBytes);\n\n            // Calculate segment duration\n            const segmentDuration = duration / segmentCount;\n            logger.debug(`Splitting ${filePath} (${fileSize} bytes) into ${segmentCount} segments of ~${segmentDuration} seconds each`);\n\n            // Create output directory if it doesn't exist\n            await storage.createDirectory(outputDir);\n\n            const outputFiles: string[] = [];\n            const fileExt = path.extname(filePath);\n            const fileName = path.basename(filePath, fileExt);\n\n            // Create a promise for each segment\n            const promises = [];\n\n            for (let i = 0; i < segmentCount; i++) {\n                const startTime = i * segmentDuration;\n                const outputPath = path.join(outputDir, `${fileName}_part${i + 1}${fileExt}`);\n                outputFiles.push(outputPath);\n\n                const promise = new Promise<void>((resolve, reject) => {\n                    ffmpeg(filePath)\n                        .setStartTime(startTime)\n                        .setDuration(segmentDuration)\n                        .output(outputPath)\n                        .on('end', () => {\n                            logger.debug(`Created segment ${i + 1}/${segmentCount}: ${outputPath}`);\n                            resolve();\n                        })\n                        .on('error', (err) => {\n                            logger.error(`Error creating segment ${i + 1}/${segmentCount}: ${err}`);\n                            reject(err);\n                        })\n                        .run();\n                });\n\n                promises.push(promise);\n            }\n\n            // Wait for all segments to be created\n            await Promise.all(promises);\n            return outputFiles;\n        } catch (error) {\n            logger.error('Error splitting audio file: %s', error);\n            throw new Error(`Failed to split audio file ${filePath}: ${error}`);\n        }\n    };\n\n    // Convert audio file to a format supported by OpenAI Whisper API\n    // Supported formats: flac, m4a, mp3, mp4, mpeg, mpga, oga, ogg, wav, webm\n    const convertToSupportedFormat = async (filePath: string, outputDir: string, forceConversion = false): Promise<string> => {\n        try {\n            const fileExt = path.extname(filePath).toLowerCase();\n\n            // List of formats that OpenAI supports\n            const supportedFormats = ['.flac', '.m4a', '.mp3', '.mp4', '.mpeg', '.mpga', '.oga', '.ogg', '.wav', '.webm'];\n\n            // If already in a supported format and not forcing conversion, return as-is\n            if (supportedFormats.includes(fileExt) && !forceConversion) {\n                logger.debug(`File ${filePath} is already in a supported format: ${fileExt}`);\n                return filePath;\n            }\n\n            // If forcing conversion and already MP3, return as-is (MP3 is already compressed)\n            if (forceConversion && fileExt === '.mp3') {\n                logger.debug(`File ${filePath} is already MP3 (compressed format)`);\n                return filePath;\n            }\n\n            // Otherwise, convert to mp3 (widely supported and good compression)\n            logger.info(`Converting ${fileExt} file to mp3 for transcription...`);\n            const fileName = path.basename(filePath, fileExt);\n            const outputPath = path.join(outputDir, `${fileName}.mp3`);\n\n            // Check if converted file already exists\n            if (await storage.exists(outputPath)) {\n                logger.debug(`Converted file already exists: ${outputPath}`);\n                return outputPath;\n            }\n\n            // Create output directory if it doesn't exist\n            await storage.createDirectory(outputDir);\n\n            return new Promise<string>((resolve, reject) => {\n                ffmpeg(filePath)\n                    .toFormat('mp3')\n                    .audioBitrate('128k')\n                    .output(outputPath)\n                    .on('end', () => {\n                        logger.info(`Successfully converted to: ${outputPath}`);\n                        resolve(outputPath);\n                    })\n                    .on('error', (err) => {\n                        logger.error(`Error converting audio file: ${err}`);\n                        reject(new Error(`Failed to convert ${filePath} to mp3: ${err.message}`));\n                    })\n                    .run();\n            });\n        } catch (error) {\n            logger.error('Error in convertToSupportedFormat: %s', error);\n            throw new Error(`Failed to convert audio file ${filePath}: ${error}`);\n        }\n    };\n\n    return {\n        getAudioCreationTime,\n        getFileSize,\n        splitAudioFile,\n        convertToSupportedFormat,\n    }\n}\n"],"names":["storage","Storage.create","path"],"mappings":"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"}

package/dist/index14.js

@@ -0,0 +1,296 @@
+const formatMetadataMarkdown = (metadata) => {
+  const lines = [];
+  if (metadata.title) {
+    lines.push(`# ${metadata.title}`);
+    lines.push("");
+  }
+  lines.push("## Metadata");
+  lines.push("");
+  if (metadata.date) {
+    const dateStr = metadata.date.toLocaleDateString("en-US", {
+      year: "numeric",
+      month: "long",
+      day: "numeric"
+    });
+    lines.push(`**Date**: ${dateStr}`);
+    if (metadata.recordingTime) {
+      lines.push(`**Time**: ${metadata.recordingTime}`);
+    } else {
+      const timeStr = metadata.date.toLocaleTimeString("en-US", {
+        hour: "2-digit",
+        minute: "2-digit",
+        hour12: true
+      });
+      lines.push(`**Time**: ${timeStr}`);
+    }
+  }
+  lines.push("");
+  if (metadata.project) {
+    lines.push(`**Project**: ${metadata.project}`);
+    if (metadata.projectId) {
+      lines.push(`**Project ID**: \`${metadata.projectId}\``);
+    }
+    lines.push("");
+  }
+  if (metadata.routing) {
+    lines.push("### Routing");
+    lines.push("");
+    lines.push(`**Destination**: ${metadata.routing.destination}`);
+    lines.push(`**Confidence**: ${(metadata.routing.confidence * 100).toFixed(1)}%`);
+    lines.push("");
+    if (metadata.routing.signals.length > 0) {
+      lines.push("**Classification Signals**:");
+      for (const signal of metadata.routing.signals) {
+        const signalType = signal.type.replace(/_/g, " ");
+        const weight = (signal.weight * 100).toFixed(0);
+        lines.push(`- ${signalType}: "${signal.value}" (${weight}% weight)`);
+      }
+      lines.push("");
+    }
+    if (metadata.routing.reasoning) {
+      lines.push(`**Reasoning**: ${metadata.routing.reasoning}`);
+      lines.push("");
+    }
+  }
+  if (metadata.tags && metadata.tags.length > 0) {
+    lines.push("**Tags**: " + metadata.tags.map((tag) => `\`${tag}\``).join(", "));
+    lines.push("");
+  }
+  if (metadata.duration) {
+    lines.push(`**Duration**: ${metadata.duration}`);
+    lines.push("");
+  }
+  lines.push("---");
+  lines.push("");
+  return lines.join("\n");
+};
+const formatEntityMetadataMarkdown = (metadata) => {
+  if (!metadata.entities) {
+    return "";
+  }
+  const lines = [];
+  lines.push("");
+  lines.push("---");
+  lines.push("");
+  lines.push("## Entity References");
+  lines.push("");
+  lines.push("<!-- Machine-readable entity metadata for indexing and querying -->");
+  lines.push("");
+  if (metadata.entities.people && metadata.entities.people.length > 0) {
+    lines.push("### People");
+    lines.push("");
+    for (const person of metadata.entities.people) {
+      lines.push(`- \`${person.id}\`: ${person.name}`);
+    }
+    lines.push("");
+  }
+  if (metadata.entities.projects && metadata.entities.projects.length > 0) {
+    lines.push("### Projects");
+    lines.push("");
+    for (const project of metadata.entities.projects) {
+      lines.push(`- \`${project.id}\`: ${project.name}`);
+    }
+    lines.push("");
+  }
+  if (metadata.entities.terms && metadata.entities.terms.length > 0) {
+    lines.push("### Terms");
+    lines.push("");
+    for (const term of metadata.entities.terms) {
+      lines.push(`- \`${term.id}\`: ${term.name}`);
+    }
+    lines.push("");
+  }
+  if (metadata.entities.companies && metadata.entities.companies.length > 0) {
+    lines.push("### Companies");
+    lines.push("");
+    for (const company of metadata.entities.companies) {
+      lines.push(`- \`${company.id}\`: ${company.name}`);
+    }
+    lines.push("");
+  }
+  return lines.join("\n");
+};
+const parseEntityMetadata = (content) => {
+  const headerIndex = content.indexOf("## Entity References");
+  if (headerIndex === -1) {
+    return void 0;
+  }
+  let contentStart = headerIndex + "## Entity References".length;
+  while (contentStart < content.length && (content[contentStart] === "\n" || content[contentStart] === "\r" || content[contentStart] === " " || content[contentStart] === "	")) {
+    contentStart++;
+  }
+  const remainingContent = content.substring(contentStart);
+  const nextHeaderMatch = remainingContent.match(/\n## /);
+  const sectionContent = nextHeaderMatch ? remainingContent.substring(0, nextHeaderMatch.index) : remainingContent;
+  const entities = {
+    people: [],
+    projects: [],
+    terms: [],
+    companies: []
+  };
+  const parseEntities = (type) => {
+    const typeMap = {
+      "People": "person",
+      "Projects": "project",
+      "Terms": "term",
+      "Companies": "company"
+    };
+    const entityType = typeMap[type];
+    const sectionHeader = `### ${type}`;
+    const sectionStart = sectionContent.indexOf(sectionHeader);
+    if (sectionStart === -1) return [];
+    const headerEnd = sectionStart + sectionHeader.length;
+    let sectionTextStart = headerEnd;
+    while (sectionTextStart < sectionContent.length && (sectionContent[sectionTextStart] === "\n" || sectionContent[sectionTextStart] === "\r" || sectionContent[sectionTextStart] === " ")) {
+      sectionTextStart++;
+    }
+    const afterSection = sectionContent.substring(sectionTextStart);
+    const nextSection = afterSection.search(/\n###/);
+    const sectionText = nextSection === -1 ? afterSection : afterSection.substring(0, nextSection);
+    const items = [];
+    const lines = sectionText.split("\n");
+    for (const line of lines) {
+      const trimmed = line.trim();
+      const match = trimmed.match(/^- `([^`]+)`:\s*(.+)$/);
+      if (match) {
+        items.push({
+          id: match[1],
+          name: match[2].trim(),
+          type: entityType
+        });
+      }
+    }
+    return items;
+  };
+  entities.people = parseEntities("People");
+  entities.projects = parseEntities("Projects");
+  entities.terms = parseEntities("Terms");
+  entities.companies = parseEntities("Companies");
+  const hasEntities = entities.people.length > 0 || entities.projects.length > 0 || entities.terms.length > 0 || entities.companies.length > 0;
+  return hasEntities ? entities : void 0;
+};
+const createRoutingMetadata = (decision) => {
+  return {
+    destination: decision.destination.path,
+    confidence: decision.confidence,
+    signals: decision.signals,
+    reasoning: decision.reasoning
+  };
+};
+const formatDuration = (seconds) => {
+  const minutes = Math.floor(seconds / 60);
+  const secs = Math.round(seconds % 60);
+  if (minutes === 0) {
+    return `${secs}s`;
+  }
+  if (secs === 0) {
+    return `${minutes}m`;
+  }
+  return `${minutes}m ${secs}s`;
+};
+const formatTime = (date) => {
+  return date.toLocaleTimeString("en-US", {
+    hour: "2-digit",
+    minute: "2-digit",
+    hour12: true
+  });
+};
+const extractTopicFromSignals = (signals) => {
+  const topicSignal = signals.find((s) => s.type === "topic" || s.type === "context_type");
+  return topicSignal?.value;
+};
+const extractTagsFromSignals = (signals) => {
+  const tags = signals.filter((s) => s.type !== "context_type").map((s) => s.value).filter((v) => typeof v === "string");
+  return Array.from(new Set(tags));
+};
+const VALID_STATUSES = [
+  "initial",
+  "enhanced",
+  "reviewed",
+  "in_progress",
+  "closed",
+  "archived"
+];
+const isValidStatus = (status) => {
+  return VALID_STATUSES.includes(status);
+};
+const generateTaskId = () => {
+  const timestamp = Date.now();
+  const random = Math.random().toString(36).substring(2, 8);
+  return `task-${timestamp}-${random}`;
+};
+const createTask = (description) => {
+  return {
+    id: generateTaskId(),
+    description,
+    status: "open",
+    created: (/* @__PURE__ */ new Date()).toISOString()
+  };
+};
+const updateStatus = (metadata, newStatus) => {
+  const oldStatus = metadata.status;
+  if (oldStatus === newStatus) {
+    return metadata;
+  }
+  const transition = {
+    from: oldStatus || "reviewed",
+    to: newStatus,
+    at: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  return {
+    ...metadata,
+    status: newStatus,
+    history: [...metadata.history || [], transition]
+  };
+};
+const applyLifecycleDefaults = (metadata) => {
+  return {
+    ...metadata,
+    status: metadata.status ?? "reviewed",
+    history: metadata.history ?? [],
+    tasks: metadata.tasks ?? []
+  };
+};
+const completeTask = (metadata, taskId) => {
+  const tasks = metadata.tasks || [];
+  const taskIndex = tasks.findIndex((t) => t.id === taskId);
+  if (taskIndex === -1) {
+    throw new Error(`Task not found: ${taskId}`);
+  }
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const updatedTasks = [...tasks];
+  updatedTasks[taskIndex] = {
+    ...updatedTasks[taskIndex],
+    status: "done",
+    changed: now,
+    completed: now
+  };
+  return {
+    ...metadata,
+    tasks: updatedTasks
+  };
+};
+const deleteTask = (metadata, taskId) => {
+  const tasks = metadata.tasks || [];
+  const taskIndex = tasks.findIndex((t) => t.id === taskId);
+  if (taskIndex === -1) {
+    throw new Error(`Task not found: ${taskId}`);
+  }
+  return {
+    ...metadata,
+    tasks: tasks.filter((t) => t.id !== taskId)
+  };
+};
+const addTask = (metadata, description) => {
+  const task = createTask(description);
+  return {
+    metadata: {
+      ...metadata,
+      tasks: [...metadata.tasks || [], task]
+    },
+    task
+  };
+};
+
+export { VALID_STATUSES, addTask, applyLifecycleDefaults, completeTask, createRoutingMetadata, createTask, deleteTask, extractTagsFromSignals, extractTopicFromSignals, formatDuration, formatEntityMetadataMarkdown, formatMetadataMarkdown, formatTime, generateTaskId, isValidStatus, parseEntityMetadata, updateStatus };
+//# sourceMappingURL=index14.js.map