@redaksjon/protokoll 1.0.1 → 1.0.7

package/dist/term-assist.js

@@ -14,7 +14,7 @@ import 'node:crypto';
 import 'node:fs/promises';
 import 'html-to-text';
 import 'commander';
-import '@theunwalked/overcontext';
+import '@utilarium/overcontext';
 import '@redaksjon/context';
 import 'js-yaml';
 import 'winston';

package/dist/term-context.js

@@ -14,7 +14,7 @@ import 'node:crypto';
 import 'node:fs/promises';
 import 'html-to-text';
 import 'commander';
-import '@theunwalked/overcontext';
+import '@utilarium/overcontext';
 import '@redaksjon/context';
 import 'js-yaml';
 import 'winston';

package/dist/transcript.js

@@ -16,12 +16,12 @@ import crypto from 'node:crypto';
 import * as fs$1 from 'node:fs/promises';
 import { htmlToText } from 'html-to-text';
 import { Command } from 'commander';
-import { discoverOvercontext, discoverContextRoot } from '@theunwalked/overcontext';
+import { discoverOvercontext, discoverContextRoot } from '@utilarium/overcontext';
 import { redaksjonPluralNames, redaksjonSchemas } from '@redaksjon/context';
 import * as yaml from 'js-yaml';
 import winston from 'winston';
 
-const VERSION = "1.0.1 (HEAD/0bd151a T:v1.0.1 2026-01-28 08:20:31 -0800) linux x64 v24.13.0";
+const VERSION = "1.0.7 (HEAD/2b22e4f T:v1.0.7 2026-01-30 15:54:52 -0800) linux x64 v24.13.0";
 const PROGRAM_NAME = "protokoll";
 const DEFAULT_DIFF = true;
 const DEFAULT_LOG = false;
@@ -220,6 +220,9 @@ const create$w = (params) => {
   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;
@@ -241,15 +244,11 @@ const create$w = (params) => {
     hashFile,
     listFiles,
     deleteFile,
+    deleteDirectory,
     getFileSize
   };
 };
 
-const protokollDiscoveryOptions = {
-  contextDirName: ".protokoll/context",
-  maxLevels: 10
-};
-
 const TYPE_TO_DIRECTORY = {
   person: "people",
   project: "projects",
@@ -279,13 +278,16 @@ const create$v = () => {
       }
       try {
         const lastContextDir = contextDirs[contextDirs.length - 1];
-        const protokollDir = lastContextDir.replace(/\/context$/, "");
-        const startDir = protokollDir.replace(/\/\.protokoll$/, "");
+        const startDir = path.dirname(lastContextDir);
         api = await discoverOvercontext({
           schemas: redaksjonSchemas,
           pluralNames: redaksjonPluralNames,
+          // Use standard names without context/ prefix
           startDir,
-          ...protokollDiscoveryOptions
+          contextDirName: path.basename(lastContextDir),
+          // Use actual context dir name
+          maxLevels: 1
+          // Limit discovery to prevent finding unrelated parent contexts
         });
         for (const type of ["person", "project", "company", "term", "ignored"]) {
           const entities = await api.getAll(type);
@@ -301,12 +303,12 @@ const create$v = () => {
         }
       }
     },
-    async save(entity, _targetDir) {
+    async save(entity, _targetDir, allowUpdate = false) {
+      const existing = cache.get(entity.type)?.get(entity.id);
+      if (existing && !allowUpdate) {
+        throw new Error(`Entity with id "${entity.id}" already exists`);
+      }
       if (!api) {
-        const existing = cache.get(entity.type)?.get(entity.id);
-        if (existing) {
-          throw new Error(`Entity with id "${entity.id}" already exists`);
-        }
         cache.get(entity.type)?.set(entity.id, entity);
         return;
       }
@@ -397,6 +399,36 @@ const discoverConfigDirectories = async (options) => {
     level: dir.level
   }));
 };
+const resolveContextDirectory = async (protokollDirPath, config) => {
+  const repoRoot = path.dirname(protokollDirPath);
+  if (config && typeof config.contextDirectory === "string") {
+    const explicitPath = path.isAbsolute(config.contextDirectory) ? config.contextDirectory : path.resolve(repoRoot, config.contextDirectory);
+    try {
+      const stat = await fs$1.stat(explicitPath);
+      if (stat.isDirectory()) {
+        return explicitPath;
+      }
+    } catch {
+    }
+  }
+  const rootContextDir = path.join(repoRoot, "context");
+  try {
+    const stat = await fs$1.stat(rootContextDir);
+    if (stat.isDirectory()) {
+      return rootContextDir;
+    }
+  } catch {
+  }
+  const legacyContextDir = path.join(protokollDirPath, "context");
+  try {
+    const stat = await fs$1.stat(legacyContextDir);
+    if (stat.isDirectory()) {
+      return legacyContextDir;
+    }
+  } catch {
+  }
+  return null;
+};
 const loadHierarchicalConfig = async (options) => {
   const discovered = await discoverConfigDirectories(options);
   if (discovered.length === 0) {
@@ -411,21 +443,19 @@ const loadHierarchicalConfig = async (options) => {
   const contextDirs = [];
   for (const dir of sortedDirs) {
     const configPath = path.join(dir.path, options.configFileName);
+    let parsedConfig = null;
     try {
       const content = await fs$1.readFile(configPath, "utf-8");
       const parsed = yaml.load(content);
       if (parsed && typeof parsed === "object") {
-        configs.push(parsed);
+        parsedConfig = parsed;
+        configs.push(parsedConfig);
       }
     } catch {
     }
-    const contextDir = path.join(dir.path, "context");
-    try {
-      const stat = await fs$1.stat(contextDir);
-      if (stat.isDirectory()) {
-        contextDirs.push(contextDir);
-      }
-    } catch {
+    const contextDir = await resolveContextDirectory(dir.path, parsedConfig);
+    if (contextDir) {
+      contextDirs.push(contextDir);
     }
   }
   const mergedConfig = configs.reduce(
@@ -567,12 +597,12 @@ const create$u = async (options = {}) => {
       }
       return related.sort((a, b) => a.distance - b.distance).map((r) => r.project);
     },
-    saveEntity: async (entity) => {
+    saveEntity: async (entity, allowUpdate = false) => {
       const closestDir = discoveryResult.discoveredDirs.sort((a, b) => a.level - b.level)[0];
       if (!closestDir) {
         throw new Error("No .protokoll directory found. Run with --init-config to create one.");
       }
-      await storage.save(entity, closestDir.path);
+      await storage.save(entity, closestDir.path, allowUpdate);
     },
     deleteEntity: async (entity) => {
       const filePath = storage.getEntityFilePath(entity.type, entity.id, discoveryResult.contextDirs);
@@ -2968,14 +2998,18 @@ const create$g = (logger) => {
       throw new Error(`Failed to split audio file ${filePath}: ${error}`);
     }
   };
-  const convertToSupportedFormat = async (filePath, outputDir) => {
+  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)) {
+      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`);
@@ -3043,25 +3077,80 @@ const create$f = (openai) => {
   const transcribe = async (request) => {
     const { audioFile, config } = request;
     logger.debug("Starting transcription", { model: config.model, file: audioFile });
+    const MAX_AUDIO_SIZE = 26214400;
     const tempDir = path.join(os.tmpdir(), "protokoll-conversions");
-    const convertedAudioFile = await media.convertToSupportedFormat(audioFile, tempDir);
+    const originalFileSize = await media.getFileSize(audioFile);
+    const originalFileSizeMB = (originalFileSize / (1024 * 1024)).toFixed(1);
+    logger.debug(`Original audio file size: ${originalFileSize} bytes (${originalFileSizeMB} MB)`);
+    const needsConversion = originalFileSize > MAX_AUDIO_SIZE * 0.95;
+    const convertedAudioFile = needsConversion ? await media.convertToSupportedFormat(audioFile, tempDir, true) : 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,
-      file: audioStream,
-      response_format: config.response_format ?? "json",
-      ...config.language && { language: config.language },
-      ...config.temperature !== void 0 && { temperature: config.temperature },
-      ...config.prompt && { prompt: config.prompt }
-    });
-    const duration = Date.now() - startTime;
-    logger.debug("Transcription complete", { duration, model: config.model });
+    const fileSize = await media.getFileSize(convertedAudioFile);
+    const fileSizeMB = (fileSize / (1024 * 1024)).toFixed(1);
+    logger.debug(`Audio file size: ${fileSize} bytes (${fileSizeMB} MB), max size: ${MAX_AUDIO_SIZE} bytes`);
+    let transcriptionText;
+    let totalDuration = 0;
+    if (fileSize > MAX_AUDIO_SIZE) {
+      logger.info(`Audio file exceeds maximum size (${fileSize} > ${MAX_AUDIO_SIZE} bytes), splitting into chunks`);
+      const splitTempDir = path.join(tempDir, `split_audio_${Date.now()}`);
+      await storage.createDirectory(splitTempDir);
+      try {
+        const audioChunks = await media.splitAudioFile(convertedAudioFile, splitTempDir, MAX_AUDIO_SIZE);
+        logger.info(`Split audio file into ${audioChunks.length} chunks`);
+        const transcriptions = [];
+        for (let i = 0; i < audioChunks.length; i++) {
+          const chunkPath = audioChunks[i];
+          logger.info(`Transcribing chunk ${i + 1}/${audioChunks.length}: ${chunkPath}`);
+          const chunkStream = await storage.readStream(chunkPath);
+          const chunkStartTime = Date.now();
+          const chunkResponse = await openai.audio.transcriptions.create({
+            model: config.model,
+            file: chunkStream,
+            response_format: config.response_format ?? "json",
+            ...config.language && { language: config.language },
+            ...config.temperature !== void 0 && { temperature: config.temperature },
+            ...config.prompt && { prompt: config.prompt }
+          });
+          const chunkDuration = Date.now() - chunkStartTime;
+          totalDuration += chunkDuration;
+          transcriptions.push(chunkResponse.text);
+        }
+        transcriptionText = transcriptions.join(" ");
+        for (const chunk of audioChunks) {
+          try {
+            await storage.deleteFile(chunk);
+          } catch (error) {
+            logger.warn(`Failed to delete temporary chunk ${chunk}: ${error}`);
+          }
+        }
+        try {
+          await storage.deleteDirectory(splitTempDir);
+        } catch (error) {
+          logger.warn(`Failed to delete temporary split directory ${splitTempDir}: ${error}`);
+        }
+      } catch (error) {
+        logger.error(`Error processing split audio files: ${error}`);
+        throw new Error(`Failed to process split audio files: ${error}`);
+      }
+    } else {
+      const audioStream = await storage.readStream(convertedAudioFile);
+      const startTime = Date.now();
+      const response = await openai.audio.transcriptions.create({
+        model: config.model,
+        file: audioStream,
+        response_format: config.response_format ?? "json",
+        ...config.language && { language: config.language },
+        ...config.temperature !== void 0 && { temperature: config.temperature },
+        ...config.prompt && { prompt: config.prompt }
+      });
+      totalDuration = Date.now() - startTime;
+      transcriptionText = response.text;
+    }
+    logger.debug("Transcription complete", { duration: totalDuration, model: config.model });
     return {
-      text: response.text,
+      text: transcriptionText,
       model: config.model,
-      duration
+      duration: totalDuration
     };
   };
   return {
@@ -5524,7 +5613,9 @@ const combineTranscripts = async (filePaths, options = {}) => {
   });
   const firstTranscript = transcripts[0];
   const baseMetadata = { ...firstTranscript.metadata };
-  const context = await create$u();
+  const context = await create$u({
+    startingDir: options.contextDirectory || path.dirname(firstTranscript.filePath)
+  });
   let targetProject;
   if (options.projectId) {
     targetProject = context.getProject(options.projectId);
@@ -5697,7 +5788,9 @@ const parseFilePaths = (input) => {
 };
 const editTranscript = async (filePath, options) => {
   const transcript = await parseTranscript(filePath);
-  const context = await create$u();
+  const context = await create$u({
+    startingDir: options.contextDirectory || path.dirname(filePath)
+  });
   let targetProject;
   if (options.projectId) {
     targetProject = context.getProject(options.projectId);