vidistill 0.6.4 → 0.7.0

package/dist/index.js

@@ -2087,13 +2087,74 @@ async function runLinkConsensus(params) {
 // src/core/transcript-consensus.ts
 var ALIGN_WINDOW_S = 3;
 var DEDUP_WINDOW_S = 10;
+var BOUNDARY_WINDOW_S = 30;
+var MIN_OVERLAP_WORDS = 5;
+function extractWordsWithPositions(text4) {
+  const regex = /[\p{L}\p{N}_]+/gu;
+  const words = [];
+  let match;
+  while ((match = regex.exec(text4)) !== null) {
+    words.push({ lower: match[0].toLowerCase(), endPos: match.index + match[0].length });
+  }
+  return words;
+}
+function findSuffixPrefixOverlap(prevWords, currWords) {
+  const maxOverlap = Math.min(prevWords.length, currWords.length);
+  for (let len = maxOverlap; len >= MIN_OVERLAP_WORDS; len--) {
+    const offset = prevWords.length - len;
+    let match = true;
+    for (let k = 0; k < len; k++) {
+      if (prevWords[offset + k] !== currWords[k]) {
+        match = false;
+        break;
+      }
+    }
+    if (match) return len;
+  }
+  return 0;
+}
+function trimBoundaryOverlap(entries) {
+  if (entries.length <= 1) return entries;
+  const sorted = [...entries].sort(
+    (a, b) => parseTimestamp(a.timestamp) - parseTimestamp(b.timestamp)
+  );
+  const result = [sorted[0]];
+  for (let i = 1; i < sorted.length; i++) {
+    const prev = result[result.length - 1];
+    const curr = sorted[i];
+    const delta = parseTimestamp(curr.timestamp) - parseTimestamp(prev.timestamp);
+    if (delta > BOUNDARY_WINDOW_S || delta < 0) {
+      result.push(curr);
+      continue;
+    }
+    const prevWords = extractWordsWithPositions(prev.text);
+    const currWords = extractWordsWithPositions(curr.text);
+    const overlapLen = findSuffixPrefixOverlap(
+      prevWords.map((w) => w.lower),
+      currWords.map((w) => w.lower)
+    );
+    if (overlapLen < MIN_OVERLAP_WORDS) {
+      result.push(curr);
+      continue;
+    }
+    const cutPos = currWords[overlapLen - 1].endPos;
+    const remaining = curr.text.slice(cutPos).replace(/^[\s,;.!?:—–\-]+/, "").trim();
+    if (remaining.length === 0) {
+      continue;
+    }
+    result.push({ ...curr, text: remaining });
+  }
+  return result;
+}
 function isNearDuplicate(a, b) {
   const delta = Math.abs(parseTimestamp(a.timestamp) - parseTimestamp(b.timestamp));
   if (delta > DEDUP_WINDOW_S) return false;
   if (a.text === b.text) return true;
-  const shared = tokenOverlap(a.text, b.text);
-  const aTokens = a.text.split(/\s+/).length;
-  const bTokens = b.text.split(/\s+/).length;
+  const aLower = a.text.toLowerCase();
+  const bLower = b.text.toLowerCase();
+  const shared = tokenOverlap(aLower, bLower);
+  const aTokens = new Set(aLower.match(/[\p{L}\p{N}_]+/gu) ?? []).size;
+  const bTokens = new Set(bLower.match(/[\p{L}\p{N}_]+/gu) ?? []).size;
   const maxTokens = Math.max(aTokens, bTokens);
   const minTokens = Math.min(aTokens, bTokens);
   if (maxTokens > 0 && shared / maxTokens >= 0.8) return true;
@@ -2139,7 +2200,7 @@ function mergeTranscriptRuns(runs) {
   if (runs.length === 1) {
     return {
       ...runs[0],
-      transcript_entries: deduplicateEntries(runs[0].transcript_entries)
+      transcript_entries: trimBoundaryOverlap(deduplicateEntries(runs[0].transcript_entries))
     };
   }
   const referenceRun = runs.reduce(
@@ -2188,7 +2249,7 @@ function mergeTranscriptRuns(runs) {
   return {
     segment_index: referenceRun.segment_index,
     time_range: referenceRun.time_range,
-    transcript_entries: deduplicateEntries(mergedEntries)
+    transcript_entries: trimBoundaryOverlap(deduplicateEntries(mergedEntries))
   };
 }
 function mergeSpeakerSummaries(summaries) {
@@ -2288,7 +2349,8 @@ async function runTranscriptionConsensus(params) {
     return { result: null, runsCompleted: 0, runsAttempted: runs };
   }
   if (runs === 1 && runsCompleted === 1) {
-    return { result: successfulRuns[0], runsCompleted: 1, runsAttempted: 1 };
+    const result = mergeTranscriptRuns(successfulRuns);
+    return { result, runsCompleted: 1, runsAttempted: 1 };
   }
   const merged = mergeTranscriptRuns(successfulRuns);
   return { result: merged, runsCompleted, runsAttempted: runs };
@@ -3699,6 +3761,18 @@ function writeTranscript(params) {
     curr.transcript_entries = curr.transcript_entries.filter(
       (entry) => !tail.some((prevEntry) => isNearDuplicate(entry, prevEntry))
     );
+    if (curr.transcript_entries.length > 0 && prev.transcript_entries.length > 0) {
+      const boundaryRegion = [
+        prev.transcript_entries[prev.transcript_entries.length - 1],
+        curr.transcript_entries[0]
+      ];
+      const trimmed = trimBoundaryOverlap(boundaryRegion);
+      if (trimmed.length < 2) {
+        curr.transcript_entries.shift();
+      } else if (trimmed[1].text !== curr.transcript_entries[0].text) {
+        curr.transcript_entries[0] = { ...curr.transcript_entries[0], text: trimmed[1].text };
+      }
+    }
   }
   for (const seg of segmentsWithPass1) {
     if (seg.pass1 != null) {
@@ -3760,6 +3834,28 @@ function writeCombined(params) {
   const { pipelineResult, speakerMapping } = params;
   const { segments } = pipelineResult;
   const sections = ["# Combined View", "", "_Chronological interleaving of speech, code, and visuals._", ""];
+  const segmentsWithPass1 = segments.filter((s) => s.pass1 != null);
+  for (let i = 1; i < segmentsWithPass1.length; i++) {
+    const prev = segmentsWithPass1[i - 1].pass1;
+    const curr = segmentsWithPass1[i].pass1;
+    if (prev == null || curr == null) continue;
+    const tail = prev.transcript_entries.slice(-5);
+    curr.transcript_entries = curr.transcript_entries.filter(
+      (entry) => !tail.some((prevEntry) => isNearDuplicate(entry, prevEntry))
+    );
+    if (curr.transcript_entries.length > 0 && prev.transcript_entries.length > 0) {
+      const boundaryRegion = [
+        prev.transcript_entries[prev.transcript_entries.length - 1],
+        curr.transcript_entries[0]
+      ];
+      const trimmed = trimBoundaryOverlap(boundaryRegion);
+      if (trimmed.length < 2) {
+        curr.transcript_entries.shift();
+      } else if (trimmed[1].text !== curr.transcript_entries[0].text) {
+        curr.transcript_entries[0] = { ...curr.transcript_entries[0], text: trimmed[1].text };
+      }
+    }
+  }
   for (const seg of segments) {
     const { pass1, pass2 } = seg;
     const timeRange = pass1?.time_range ?? pass2?.time_range ?? `Segment ${seg.index + 1}`;
@@ -5621,7 +5717,7 @@ async function run2(args) {
 }
 
 // src/cli/index.ts
-var version = "0.6.4";
+var version = "0.7.0";
 var DEFAULT_OUTPUT2 = "./vidistill-output/";
 var SUBCOMMANDS = {
   mcp: run,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vidistill",
-  "version": "0.6.4",
+  "version": "0.7.0",
   "description": "Video intelligence distiller — extract structured notes, transcripts, and insights from any video using Gemini",
   "type": "module",
   "license": "MIT",