project-graph-mcp 2.3.0 → 2.3.2

package/vendor/symbiote-node/engine/packs/io/write-file.handler.js

@@ -0,0 +1,63 @@
+/**
+ * io/write-file — Write content to file
+ *
+ * Writes string or JSON content to disk. Creates directories if needed.
+ *
+ * @module agi-graph/packs/io/write-file
+ */
+
+import { promises as fs } from 'fs';
+import path from 'path';
+
+export default {
+  type: 'io/write-file',
+  category: 'io',
+  icon: 'save',
+
+  driver: {
+    description: 'Write content to file (auto-creates directories)',
+    inputs: [
+      { name: 'path', type: 'string' },
+      { name: 'content', type: 'any' },
+    ],
+    outputs: [
+      { name: 'success', type: 'boolean' },
+      { name: 'path', type: 'string' },
+      { name: 'error', type: 'string' },
+    ],
+    params: {
+      encoding: { type: 'string', default: 'utf8', description: 'File encoding' },
+      pretty: { type: 'boolean', default: true, description: 'Pretty-print JSON' },
+    },
+  },
+
+  lifecycle: {
+    validate: (inputs) => {
+      if (!inputs.path) return false;
+      if (inputs.content === undefined || inputs.content === null) return false;
+      return true;
+    },
+
+    cacheKey: null,
+
+    execute: async (inputs, params) => {
+      try {
+        await fs.mkdir(path.dirname(inputs.path), { recursive: true });
+
+        let data;
+        if (typeof inputs.content === 'object') {
+          data = JSON.stringify(inputs.content, null, params.pretty ? 2 : 0);
+        } else {
+          data = String(inputs.content);
+        }
+
+        await fs.writeFile(inputs.path, data, params.encoding || 'utf8');
+
+        return { success: true, path: inputs.path, error: null };
+
+      } catch (err) {
+        return { success: false, path: inputs.path, error: err.message };
+      }
+    },
+  },
+};

package/vendor/symbiote-node/engine/packs/transform/anchor-match.handler.js

@@ -0,0 +1,494 @@
+/**
+ * transform/anchor-match — Lyrics ↔ Audio alignment with word-level karaoke timing
+ *
+ * Aligns reference lyrics with Whisper transcription timestamps.
+ * Supports fuzzy matching (edit distance) and AI correction (OpenRouter).
+ * Produces word-level timing data for karaoke rendering.
+ *
+ * Ported from Mr-Computer/modules/ai-music-video/src/services/anchor-matcher.js
+ *
+ * @module agi-graph/packs/transform/anchor-match
+ */
+
+export default {
+  type: 'transform/anchor-match',
+  category: 'transform',
+  icon: 'lyrics',
+
+  driver: {
+    description: 'Align lyrics with Whisper timestamps — word-level karaoke timing',
+    inputs: [
+      { name: 'lyrics', type: 'string' },
+      { name: 'whisperWords', type: 'any' },
+    ],
+    outputs: [
+      { name: 'phrases', type: 'any' },
+      { name: 'segments', type: 'any' },
+      { name: 'stats', type: 'any' },
+      { name: 'error', type: 'string' },
+    ],
+    params: {
+      operation: { type: 'string', default: 'align', description: 'Operation: align | align-fuzzy | parse-lyrics' },
+      apiKey: { type: 'string', default: '', description: 'OpenRouter API key for AI correction' },
+      model: { type: 'string', default: 'deepseek/deepseek-v3.2', description: 'AI model for correction' },
+      maxPhraseWords: { type: 'int', default: 8, description: 'Max words per phrase for subtitle readability' },
+    },
+  },
+
+  lifecycle: {
+    validate: (inputs) => {
+      if (!inputs.lyrics && !inputs.whisperWords) return false;
+      return true;
+    },
+
+    cacheKey: (inputs, params) => {
+      const lLen = (inputs.lyrics || '').length;
+      const wLen = (inputs.whisperWords || []).length;
+      return `anchor:${params.operation}:${lLen}:${wLen}`;
+    },
+
+    execute: async (inputs, params) => {
+      try {
+        const op = params.operation;
+
+        if (op === 'parse-lyrics') {
+          const segments = parseLyrics(inputs.lyrics);
+          return { phrases: null, segments, stats: { sections: segments.length }, error: null };
+        }
+
+        if (!inputs.whisperWords || !Array.isArray(inputs.whisperWords) || inputs.whisperWords.length === 0) {
+          return { phrases: null, segments: null, stats: null, error: 'whisperWords array is required for alignment' };
+        }
+
+        const segments = parseLyrics(inputs.lyrics);
+
+        if (op === 'align-fuzzy') {
+          const phrases = alignWithFuzzy(segments, inputs.whisperWords);
+          return {
+            phrases,
+            segments,
+            stats: { mode: 'fuzzy', phraseCount: phrases.length, sectionCount: segments.length },
+            error: null,
+          };
+        }
+
+        // Default: hybrid align (fuzzy + optional AI correction)
+        const phrases = await alignHybrid(inputs.lyrics, inputs.whisperWords, segments, params);
+        return {
+          phrases,
+          segments,
+          stats: {
+            mode: params.apiKey ? 'hybrid-ai' : 'fuzzy-corrected',
+            phraseCount: phrases.length,
+            sectionCount: segments.length,
+            totalWords: inputs.whisperWords.length,
+          },
+          error: null,
+        };
+      } catch (err) {
+        return { phrases: null, segments: null, stats: null, error: err.message };
+      }
+    },
+  },
+};
+
+// --- Core alignment functions (ported from anchor-matcher.js) ---
+
+/**
+ * Parse lyrics into structured segments
+ * @param {string} lyricsText - Raw lyrics with [Section] markers
+ * @returns {Array<{section: string, lines: string[]}>}
+ */
+function parseLyrics(lyricsText) {
+  if (!lyricsText) return [];
+  const lines = lyricsText.split('\n');
+  const segments = [];
+  let currentSection = null;
+  let currentLines = [];
+
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (!trimmed) continue;
+
+    const sectionMatch = trimmed.match(/^\[(.+)\]$/);
+    if (sectionMatch) {
+      if (currentSection) {
+        segments.push({ section: currentSection, lines: currentLines });
+      }
+      currentSection = sectionMatch[1];
+      currentLines = [];
+    } else {
+      currentLines.push(trimmed);
+    }
+  }
+
+  if (currentSection && currentLines.length > 0) {
+    segments.push({ section: currentSection, lines: currentLines });
+  }
+
+  return segments;
+}
+
+/**
+ * Extract singable text (remove [markers], keep (parenthesis) content)
+ * @param {string} line
+ * @returns {string}
+ */
+function extractSingableText(line) {
+  return line
+    .replace(/\[.*?\]/g, '')
+    .replace(/\*\*/g, '')
+    .replace(/\(([^)]+)\)/g, '$1')
+    .trim();
+}
+
+/**
+ * Normalize word for comparison
+ * @param {string} word
+ * @returns {string}
+ */
+function normalizeWord(word) {
+  return word.toLowerCase()
+    .replace(/[.,!?¿¡'"()]/g, '')
+    .replace(/[áà]/g, 'a')
+    .replace(/[éè]/g, 'e')
+    .replace(/[íì]/g, 'i')
+    .replace(/[óò]/g, 'o')
+    .replace(/[úù]/g, 'u')
+    .replace(/ñ/g, 'n');
+}
+
+/**
+ * Levenshtein edit distance
+ * @param {string} s1
+ * @param {string} s2
+ * @returns {number}
+ */
+function editDistance(s1, s2) {
+  const m = s1.length;
+  const n = s2.length;
+  const dp = Array(m + 1).fill(null).map(() => Array(n + 1).fill(0));
+
+  for (let i = 0; i <= m; i++) dp[i][0] = i;
+  for (let j = 0; j <= n; j++) dp[0][j] = j;
+
+  for (let i = 1; i <= m; i++) {
+    for (let j = 1; j <= n; j++) {
+      if (s1[i - 1] === s2[j - 1]) {
+        dp[i][j] = dp[i - 1][j - 1];
+      } else {
+        dp[i][j] = 1 + Math.min(dp[i - 1][j], dp[i][j - 1], dp[i - 1][j - 1]);
+      }
+    }
+  }
+  return dp[m][n];
+}
+
+/**
+ * Check word similarity (fuzzy match)
+ * @param {string} word1
+ * @param {string} word2
+ * @returns {boolean}
+ */
+function wordsSimilar(word1, word2) {
+  const w1 = word1.toLowerCase().replace(/[^a-záéíóúñü]/g, '');
+  const w2 = word2.toLowerCase().replace(/[^a-záéíóúñü]/g, '');
+  if (w1 === w2) return true;
+  if (w1.length < 3 || w2.length < 3) return w1 === w2;
+  if (w1.includes(w2) || w2.includes(w1)) return true;
+  const maxErrors = Math.floor(Math.max(w1.length, w2.length) / 4);
+  return editDistance(w1, w2) <= maxErrors;
+}
+
+/**
+ * Infer section from timestamp
+ * @param {number} timestamp
+ * @param {Array} segments
+ * @returns {string}
+ */
+function inferSection(timestamp, segments) {
+  if (!segments || segments.length === 0) return 'Unknown';
+
+  for (let i = segments.length - 1; i >= 0; i--) {
+    if (segments[i].startTime !== undefined && timestamp >= segments[i].startTime) {
+      return segments[i].section;
+    }
+  }
+
+  const estimatedSectionDuration = 15;
+  const sectionIndex = Math.floor(timestamp / estimatedSectionDuration);
+  if (sectionIndex >= 0 && sectionIndex < segments.length) {
+    return segments[sectionIndex].section;
+  }
+
+  return segments[segments.length - 1].section;
+}
+
+/**
+ * Calculate section timing from word positions
+ * @param {Array} segments
+ * @param {Array} correctedWords
+ * @returns {Array}
+ */
+function calculateSectionTiming(segments, correctedWords) {
+  if (!segments || segments.length === 0) return segments;
+
+  let wordIndex = 0;
+  return segments.map(seg => {
+    let startTime = null;
+
+    for (const line of seg.lines) {
+      const singable = extractSingableText(line);
+      if (!singable) continue;
+
+      const firstWord = normalizeWord(singable.split(/\s+/)[0]);
+
+      for (let i = wordIndex; i < correctedWords.length && i < wordIndex + 50; i++) {
+        const cw = correctedWords[i];
+        if (normalizeWord(cw.word) === firstWord ||
+          editDistance(normalizeWord(cw.word), firstWord) <= 1) {
+          startTime = cw.start;
+          wordIndex = i;
+          break;
+        }
+      }
+
+      if (startTime !== null) break;
+    }
+
+    return { ...seg, startTime };
+  });
+}
+
+/**
+ * Hybrid align: vocabulary correction + phrase building
+ * @param {string} referenceLyrics
+ * @param {Array} whisperWords
+ * @param {Array} segments
+ * @param {Object} params
+ * @returns {Promise<Array>}
+ */
+async function alignHybrid(referenceLyrics, whisperWords, segments, params) {
+  // Build lyrics vocabulary
+  const lyricsVocabulary = new Map();
+  for (const seg of segments) {
+    for (const line of seg.lines) {
+      const singable = extractSingableText(line);
+      if (!singable) continue;
+      const words = singable.match(/[\w\u00C0-\u024F]+[.,!?']*|[.,!?]+/gi) || [];
+      words.forEach(w => {
+        if (w.trim()) {
+          const norm = normalizeWord(w);
+          if (!lyricsVocabulary.has(norm) || /[.,!?']$/.test(w)) {
+            lyricsVocabulary.set(norm, {
+              original: w,
+              hasPunctuation: /[.,!?']$/.test(w),
+            });
+          }
+        }
+      });
+    }
+  }
+
+  // Correct Whisper words using vocabulary
+  const correctedWords = whisperWords.map(w => {
+    const whisperNorm = normalizeWord(w.word);
+
+    // Exact match
+    if (lyricsVocabulary.has(whisperNorm)) {
+      const match = lyricsVocabulary.get(whisperNorm);
+      return {
+        word: match.original,
+        start: w.start,
+        end: w.end,
+        original: w.word,
+        isConfident: true,
+        endsPhrase: match.hasPunctuation,
+      };
+    }
+
+    // Fuzzy search vocabulary
+    let bestMatch = null;
+    let bestDistance = Infinity;
+
+    for (const [norm, lyric] of lyricsVocabulary) {
+      const dist = editDistance(whisperNorm, norm);
+      if (dist < bestDistance) {
+        bestDistance = dist;
+        bestMatch = lyric;
+      }
+      if (dist === 0) break;
+    }
+
+    const isConfident = bestDistance <= 1 ||
+      (bestDistance === 2 && whisperNorm.length > 5);
+
+    const correctedWord = isConfident && bestMatch ? bestMatch.original : w.word;
+
+    return {
+      word: correctedWord,
+      start: w.start,
+      end: w.end,
+      original: w.word,
+      isConfident,
+      endsPhrase: bestMatch?.hasPunctuation || false,
+    };
+  });
+
+  // Calculate section timing
+  const segmentsWithTiming = calculateSectionTiming(segments, correctedWords);
+
+  // Build phrases with word-level timing
+  return buildPhrasesFromCorrectedWords(correctedWords, segmentsWithTiming, params.maxPhraseWords);
+}
+
+/**
+ * Build phrases from corrected words with punctuation-based splitting
+ * @param {Array} correctedWords
+ * @param {Array} segments
+ * @param {number} maxWords
+ * @returns {Array}
+ */
+function buildPhrasesFromCorrectedWords(correctedWords, segments, maxWords = 8) {
+  const alignments = [];
+  let currentPhrase = [];
+  let phraseStart = null;
+  let lastEnd = 0;
+
+  for (let i = 0; i < correctedWords.length; i++) {
+    const w = correctedWords[i];
+
+    if (phraseStart === null) {
+      phraseStart = w.start;
+    }
+    currentPhrase.push(w.word);
+    lastEnd = w.end;
+
+    const shouldEndPhrase = w.endsPhrase || currentPhrase.length >= maxWords;
+
+    if (shouldEndPhrase) {
+      alignments.push({
+        line: currentPhrase.join(' '),
+        start: phraseStart,
+        end: w.end,
+        section: inferSection(phraseStart, segments),
+        confidence: 0.9,
+        words: correctedWords.slice(i - currentPhrase.length + 1, i + 1).map(cw => ({
+          word: cw.word,
+          start: cw.start,
+          end: cw.end,
+        })),
+      });
+      currentPhrase = [];
+      phraseStart = null;
+    }
+  }
+
+  // Last phrase
+  if (currentPhrase.length > 0 && phraseStart !== null) {
+    const startIdx = correctedWords.length - currentPhrase.length;
+    alignments.push({
+      line: currentPhrase.join(' '),
+      start: phraseStart,
+      end: lastEnd,
+      section: 'Outro',
+      confidence: 0.9,
+      words: correctedWords.slice(startIdx).map(cw => ({
+        word: cw.word,
+        start: cw.start,
+        end: cw.end,
+      })),
+    });
+  }
+
+  return alignments;
+}
+
+/**
+ * Fuzzy alignment without AI — line-level matching
+ * @param {Array} segments - Parsed lyrics segments
+ * @param {Array} whisperWords - [{word, start, end}]
+ * @returns {Array}
+ */
+function alignWithFuzzy(segments, whisperWords) {
+  const results = [];
+  let whisperIndex = 0;
+
+  for (const seg of segments) {
+    for (const line of seg.lines) {
+      const singable = extractSingableText(line);
+      if (!singable) continue;
+
+      const isExclamation = line.trim().startsWith('(');
+      const words = singable.split(/\s+/).filter(w => w.length > 0);
+      if (words.length === 0) continue;
+
+      const firstWord = normalizeWord(words[0]);
+
+      let bestMatch = null;
+      let bestScore = Infinity;
+
+      for (let i = whisperIndex; i < whisperWords.length; i++) {
+        const whisperWord = normalizeWord(whisperWords[i].word);
+
+        const isExactMatch = firstWord === whisperWord;
+        const isPartialMatch = firstWord.startsWith(whisperWord) || whisperWord.startsWith(firstWord);
+
+        if (isExactMatch) {
+          bestMatch = { index: i, word: whisperWords[i] };
+          bestScore = 0;
+          break;
+        }
+
+        if (isPartialMatch && firstWord.length >= 2) {
+          if (!bestMatch || i < bestMatch.index) {
+            bestMatch = { index: i, word: whisperWords[i] };
+            bestScore = 1;
+          }
+          continue;
+        }
+
+        const distance = editDistance(firstWord, whisperWord);
+        const threshold = Math.max(1, Math.floor(firstWord.length / 3));
+        if (distance <= threshold && distance < bestScore) {
+          bestScore = distance;
+          bestMatch = { index: i, word: whisperWords[i] };
+        }
+
+        if (i - whisperIndex > 50 && bestMatch) break;
+      }
+
+      if (bestMatch) {
+        const startTime = bestMatch.word.start;
+        let endIndex = bestMatch.index + Math.min(words.length - 1, 5);
+        if (endIndex >= whisperWords.length) endIndex = whisperWords.length - 1;
+        const endTime = whisperWords[endIndex].end;
+
+        results.push({
+          line: singable,
+          start: startTime,
+          end: endTime,
+          section: seg.section,
+          confidence: bestScore === 0 ? 0.95 : (bestScore === 1 ? 0.85 : 0.7),
+          isExclamation,
+        });
+
+        whisperIndex = bestMatch.index + 1;
+      } else {
+        const lastResult = results[results.length - 1];
+        if (lastResult) {
+          results.push({
+            line: singable,
+            start: lastResult.end + 0.5,
+            end: lastResult.end + 2.0,
+            section: seg.section,
+            confidence: 0.3,
+            isExclamation,
+          });
+        }
+      }
+    }
+  }
+
+  return results;
+}