@redaksjon/protokoll 1.0.23 → 1.0.24-dev.20260302172144.c9ea98d

package/LICENSE

@@ -175,7 +175,7 @@
 
    END OF TERMS AND CONDITIONS
 
-   Copyright 2025 Tim O'Brien
+   Copyright 2026 Tim O'Brien
 
    Licensed under the Apache License, Version 2.0 (the "License");
    you may not use this file except in compliance with the License.

package/dist/engineLogging.js

@@ -208,7 +208,7 @@ function isProtokolUri(uri) {
   return uri.startsWith(`${SCHEME}://`);
 }
 
-const VERSION = "1.0.23 (HEAD/b233b60 T:v1.0.23 2026-03-01 14:31:50 -0800) linux arm64 v24.14.0";
+const VERSION = "1.0.24-dev.20260302172144.c9ea98d (working/c9ea98d  2026-03-02 09:20:37 -0800) linux arm64 v24.14.0";
 const PROGRAM_NAME = "protokoll";
 const DATE_FORMAT_YEAR_MONTH_DAY_HOURS_MINUTES_SECONDS = "YYYY-M-D-HHmmss";
 const DEFAULT_AUDIO_EXTENSIONS = ["mp3", "mp4", "mpeg", "mpga", "m4a", "wav", "webm", "qta"];
@@ -1667,7 +1667,7 @@ function entryVersionKey(entry) {
     String(Number(entry.sourceSize || 0))
   ].join("|");
 }
-async function listFilesWithMetadataCompat$1(outputStorage, prefix, pattern) {
+async function listFilesWithMetadataCompat$2(outputStorage, prefix, pattern) {
   const withMetadata = outputStorage.listFilesWithMetadata;
   if (typeof withMetadata === "function") {
     return withMetadata.call(outputStorage, prefix, pattern);
@@ -1809,7 +1809,7 @@ class TranscriptIndexService {
   }
   async refreshIndex() {
     const refreshStartedAt = Date.now();
-    const listed = await listFilesWithMetadataCompat$1(this.outputStorage, "");
+    const listed = await listFilesWithMetadataCompat$2(this.outputStorage, "");
     const candidates = listed.map((metadata) => ({ ...metadata, path: normalizePath$1(metadata.path) })).filter((metadata) => isTranscriptCandidate(metadata.path));
     const byPath = new Map(candidates.map((metadata) => [metadata.path, metadata]));
     const dirtyAtStart = new Set(this.dirtyPaths);
@@ -2101,7 +2101,7 @@ async function resolveTranscriptPathByFilename(outputStorage, outputDirectory, t
   if (indexedMatches.length > 0) {
     return indexedMatches;
   }
-  const listed = await listFilesWithMetadataCompat$1(outputStorage, "", ".pkl");
+  const listed = await listFilesWithMetadataCompat$2(outputStorage, "", ".pkl");
   return listed.map((entry) => normalizePath$1(entry.path)).filter((entryPath) => targetFilenames.has(entryPath.split("/").pop() || ""));
 }
 
@@ -2465,7 +2465,7 @@ function isYamlPath(pathValue) {
   const normalized = normalizePath(pathValue).toLowerCase();
   return normalized.endsWith(".yaml") || normalized.endsWith(".yml");
 }
-async function listFilesWithMetadataCompat(provider, prefix, pattern) {
+async function listFilesWithMetadataCompat$1(provider, prefix, pattern) {
   if (typeof provider.listFilesWithMetadata === "function") {
     return provider.listFilesWithMetadata(prefix, pattern);
   }
@@ -2565,7 +2565,7 @@ class EntityIndexService {
       this.contextGcs.projectId
     );
     const directory = ENTITY_DIRECTORY$1[entityType];
-    const listed = await listFilesWithMetadataCompat(provider, `${directory}/`);
+    const listed = await listFilesWithMetadataCompat$1(provider, `${directory}/`);
     const yamlEntries = listed.map((metadata) => ({ ...metadata, path: normalizePath(metadata.path) })).filter((metadata) => isYamlPath(metadata.path));
     const byPath = new Map(yamlEntries.map((metadata) => [metadata.path, metadata]));
     const existing = this.byType.get(entityType) || /* @__PURE__ */ new Map();
@@ -6069,6 +6069,18 @@ async function resolveStorageTranscriptPath(transcriptPath, outputStorage) {
   }
   return null;
 }
+async function getProjectLookupContext(contextDirectory) {
+  const ServerConfig = await Promise.resolve().then(() => serverConfig$1);
+  const serverContext = ServerConfig.getContext();
+  if (serverContext?.hasContext()) {
+    return serverContext;
+  }
+  const contextDirectories = await getContextDirectories();
+  return create({
+    startingDir: contextDirectory || process.cwd(),
+    contextDirectories
+  });
+}
 async function openToolTranscript(transcriptPath, contextDirectory) {
   const ServerConfig = await Promise.resolve().then(() => serverConfig$1);
   const outputStorage = ServerConfig.getOutputStorage();
@@ -7115,6 +7127,7 @@ async function handleEditTranscript(args) {
   const outputDirectory = await getConfiguredDirectory("outputDirectory", args.contextDirectory);
   const ServerConfig = await Promise.resolve().then(() => serverConfig$1);
   const outputStorage = ServerConfig.getOutputStorage();
+  const serverContext = ServerConfig.getContext();
   if (outputStorage.name === "gcs") {
     const access = await openToolTranscript(args.transcriptPath, args.contextDirectory);
     const resolvedStoragePath = access.storagePath || access.pklPath;
@@ -7131,17 +7144,24 @@ async function handleEditTranscript(args) {
           changes2.push("title updated");
         }
         if (args.projectId) {
-          const contextDirectories = await getContextDirectories();
-          const context = await create({
-            startingDir: args.contextDirectory || process.cwd(),
-            contextDirectories
-          });
+          const context = await getProjectLookupContext(args.contextDirectory);
           const project = await context.getProject(args.projectId);
-          if (!project) {
-            throw new Error(`Project not found: ${args.projectId}`);
+          let resolvedId;
+          let resolvedName;
+          if (project) {
+            resolvedId = project.id;
+            resolvedName = project.name;
+          } else {
+            const gcsEntity = await findContextEntityInGcs("project", args.projectId);
+            if (gcsEntity && typeof gcsEntity.id === "string" && typeof gcsEntity.name === "string") {
+              resolvedId = gcsEntity.id;
+              resolvedName = gcsEntity.name;
+            } else {
+              throw new Error(`Project not found: ${args.projectId}`);
+            }
           }
-          metadataUpdates.projectId = project.id;
-          metadataUpdates.project = project.name;
+          metadataUpdates.projectId = resolvedId;
+          metadataUpdates.project = resolvedName;
           const existingEntities = transcript.metadata.entities || {
             people: [],
             projects: [],
@@ -7151,8 +7171,8 @@ async function handleEditTranscript(args) {
           metadataUpdates.entities = {
             people: existingEntities.people || [],
             projects: [{
-              id: project.id,
-              name: project.name,
+              id: resolvedId,
+              name: resolvedName,
               type: "project"
             }],
             terms: existingEntities.terms || [],
@@ -7218,7 +7238,10 @@ async function handleEditTranscript(args) {
   let finalOutputPath = absolutePath;
   let wasRenamed = false;
   if (args.title || args.projectId || args.tagsToAdd || args.tagsToRemove) {
-    const contextDirectories = await getContextDirectories();
+    let contextDirectories = await getContextDirectories();
+    if ((!contextDirectories || contextDirectories.length === 0) && serverContext?.hasContext()) {
+      contextDirectories = serverContext.getContextDirs();
+    }
     const result = await Transcript.editTranscript(absolutePath, {
       title: args.title,
       projectId: args.projectId,
@@ -7770,6 +7793,11 @@ async function handleEnhanceTranscript(args) {
       const project = context.getProject(projectId);
       if (project) {
         entities.projects.push({ id: project.id, name: project.name, type: "project" });
+      } else {
+        const gcsEntity = await findContextEntityInGcs("project", projectId);
+        if (gcsEntity && typeof gcsEntity.id === "string" && typeof gcsEntity.name === "string") {
+          entities.projects.push({ id: gcsEntity.id, name: gcsEntity.name, type: "project" });
+        }
       }
     }
     for (const termId of referenced.terms) {
@@ -7786,13 +7814,24 @@ async function handleEnhanceTranscript(args) {
     }
     const hasEntities = entities.people.length > 0 || entities.projects.length > 0 || entities.terms.length > 0 || entities.companies.length > 0;
     const decidedProjectId = agenticResult.state.routeDecision?.projectId || routeResult.projectId || void 0;
-    const decidedProject = decidedProjectId ? context.getProject(decidedProjectId) : void 0;
+    let decidedProjectName;
+    if (decidedProjectId) {
+      const decidedProject = context.getProject(decidedProjectId);
+      if (decidedProject) {
+        decidedProjectName = decidedProject.name;
+      } else {
+        const gcsEntity = await findContextEntityInGcs("project", decidedProjectId);
+        if (gcsEntity && typeof gcsEntity.name === "string") {
+          decidedProjectName = gcsEntity.name;
+        }
+      }
+    }
     const decidedConfidence = agenticResult.state.routeDecision?.confidence ?? routeResult.confidence;
     transcript.updateContent(enhancedText);
     transcript.updateMetadata({
       status: finalStatus,
       projectId: decidedProjectId || transcript.metadata.projectId,
-      project: decidedProject?.name || transcript.metadata.project,
+      project: decidedProjectName || transcript.metadata.project,
       confidence: typeof decidedConfidence === "number" ? decidedConfidence : transcript.metadata.confidence,
       entities: hasEntities ? entities : transcript.metadata.entities
     });
@@ -7817,7 +7856,7 @@ async function handleEnhanceTranscript(args) {
       transcriptPath: args.transcriptPath,
       status: finalStatus,
       projectId: decidedProjectId || null,
-      projectName: decidedProject?.name || null,
+      projectName: decidedProjectName || null,
       toolsUsed: agenticResult.toolsUsed,
       totalToolCalls: toolCallCount,
       iterations: agenticResult.iterations,
@@ -7876,14 +7915,15 @@ async function handleCreateNote(args) {
   let projectName;
   if (args.projectId) {
     try {
-      const contextDirectories = await getContextDirectories();
-      const context = await create({
-        startingDir: args.contextDirectory || process.cwd(),
-        contextDirectories
-      });
+      const context = await getProjectLookupContext(args.contextDirectory);
       const project = await context.getProject(args.projectId);
       if (project) {
         projectName = project.name;
+      } else {
+        const gcsEntity = await findContextEntityInGcs("project", args.projectId);
+        if (gcsEntity && typeof gcsEntity.name === "string") {
+          projectName = gcsEntity.name;
+        }
       }
     } catch {
     }
@@ -9164,6 +9204,82 @@ function getCompletionTime(metadata) {
   const lastTransition = metadata.history.sort((a, b) => b.at.getTime() - a.at.getTime())[0];
   return lastTransition?.at.toISOString() || "";
 }
+function isQueueCandidatePath(pathValue) {
+  const normalized = pathValue.replace(/^\/+/, "").replace(/\\/g, "/");
+  if (!normalized.toLowerCase().endsWith(".pkl")) {
+    return false;
+  }
+  if (normalized.startsWith("uploads/") || normalized.includes("/uploads/")) {
+    return false;
+  }
+  if (normalized.startsWith(".intermediate/") || normalized.includes("/.intermediate/")) {
+    return false;
+  }
+  return true;
+}
+function isUploadPlaceholderPath(pathValue) {
+  const normalized = pathValue.replace(/^\/+/, "").replace(/\\/g, "/").toLowerCase();
+  if (!normalized.endsWith("-upload.pkl")) {
+    return false;
+  }
+  return !normalized.includes("/");
+}
+async function listFilesWithMetadataCompat(provider, prefix, pattern) {
+  const withMetadata = provider.listFilesWithMetadata;
+  if (typeof withMetadata === "function") {
+    return withMetadata.call(provider, prefix, pattern);
+  }
+  const listed = await provider.listFiles(prefix, pattern);
+  return listed.map((pathValue) => ({
+    path: pathValue,
+    size: 1,
+    updatedAt: null
+  }));
+}
+async function materializeTranscriptFromStorage(outputStorage, transcriptPath) {
+  const fileName = transcriptPath.split("/").pop() || "transcript.pkl";
+  const tempPath = join(
+    tmpdir(),
+    `protokoll-queue-pkl-${Date.now()}-${Math.random().toString(36).slice(2)}-${fileName}`
+  );
+  const contents = await outputStorage.readFile(transcriptPath);
+  await fs.writeFile(tempPath, contents);
+  return tempPath;
+}
+async function findQueueTranscriptsFromStorage(outputStorage) {
+  const files = await listFilesWithMetadataCompat(outputStorage, "", "-upload.pkl");
+  const candidates = files.map((metadata) => ({ ...metadata, path: metadata.path.replace(/^\/+/, "").replace(/\\/g, "/") })).filter((metadata) => isQueueCandidatePath(metadata.path)).filter((metadata) => isUploadPlaceholderPath(metadata.path));
+  const uploaded = [];
+  const transcribing = [];
+  for (const metadata of candidates) {
+    let tempPath = null;
+    try {
+      tempPath = await materializeTranscriptFromStorage(outputStorage, metadata.path);
+      const transcript = PklTranscript.open(tempPath, { readOnly: true });
+      const transcriptMetadata = transcript.metadata;
+      await transcript.close();
+      if (transcriptMetadata.status === "uploaded") {
+        uploaded.push({ uuid: transcriptMetadata.id, metadata: transcriptMetadata });
+      } else if (transcriptMetadata.status === "transcribing") {
+        transcribing.push({ uuid: transcriptMetadata.id, metadata: transcriptMetadata });
+      }
+    } catch {
+    } finally {
+      if (tempPath) {
+        await fs.rm(tempPath, { force: true });
+      }
+    }
+  }
+  const sortByDateAsc = (a, b) => {
+    const aTime = a.metadata.date?.getTime() || 0;
+    const bTime = b.metadata.date?.getTime() || 0;
+    return aTime - bTime;
+  };
+  return {
+    uploaded: uploaded.sort(sortByDateAsc),
+    transcribing: transcribing.sort(sortByDateAsc)
+  };
+}
 async function findRecentTranscripts(searchDirectories, limit) {
   const results = [];
   const oneDayAgo = new Date(Date.now() - 24 * 60 * 60 * 1e3);
@@ -9202,8 +9318,17 @@ async function findRecentTranscripts(searchDirectories, limit) {
 }
 async function handleQueueStatus() {
   const outputDir = getOutputDirectory();
-  const uploaded = await findUploadedTranscripts([outputDir]);
-  const transcribing = await findTranscribingTranscripts([outputDir]);
+  const outputStorage = getOutputStorage();
+  let uploaded = [];
+  let transcribing = [];
+  if (outputStorage.name === "gcs") {
+    const storageQueue = await findQueueTranscriptsFromStorage(outputStorage);
+    uploaded = storageQueue.uploaded;
+    transcribing = storageQueue.transcribing;
+  } else {
+    uploaded = await findUploadedTranscripts([outputDir]);
+    transcribing = await findTranscribingTranscripts([outputDir]);
+  }
   const recent = await findRecentTranscripts([outputDir], 10);
   return {
     pending: uploaded.map((t) => ({