project-graph-mcp 2.3.2 → 2.4.0

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

@@ -1,79 +0,0 @@
-/**
- * transform/template — String template interpolation
- *
- * Replaces {{variable}} placeholders in template string with values from data object.
- * Supports nested access via dot notation: {{user.name}}.
- *
- * @module symbiote-node/packs/transform/template
- */
-
-export default {
-  type: 'transform/template',
-  category: 'transform',
-  icon: 'text_snippet',
-
-  driver: {
-    description: 'Template interpolation — replace {{var}} with data values',
-    inputs: [
-      { name: 'template', type: 'string' },
-      { name: 'data', type: 'any' },
-    ],
-    outputs: [
-      { name: 'result', type: 'string' },
-      { name: 'data', type: 'any' },
-    ],
-    params: {
-      template: { type: 'textarea', default: '', description: 'Message template ({{var}} syntax)' },
-      replyMarkup: { type: 'textarea', default: '', description: 'Inline keyboard JSON (Telegram reply_markup)' },
-    },
-  },
-
-  lifecycle: {
-    // No validate: template comes from params.template or inputs.template
-    // Execute handles both cases
-
-    cacheKey: (inputs) =>
-      `tpl:${inputs.template}:${JSON.stringify(inputs.data)}`,
-
-    execute: async (inputs, params) => {
-      const template = params?.template || inputs.template;
-      const { data } = inputs;
-
-      const result = template.replace(/\{\{([^}]+)\}\}/g, (match, key) => {
-        const trimmed = key.trim();
-        // Support dot notation: {{user.name}}
-        const value = trimmed.split('.').reduce((obj, k) => {
-          if (obj === null || obj === undefined) return undefined;
-          return obj[k];
-        }, data);
-
-        if (value === undefined) {
-          console.warn(`[template] ⚠️ Missing variable "${trimmed}" in data keys: [${data ? Object.keys(data).join(', ') : 'NO DATA'}]`);
-          return match;
-        }
-        if (typeof value === 'object') return JSON.stringify(value);
-        return String(value);
-      });
-
-      // Output rendered text in both formats:
-      // - result: raw string (for chaining)
-      // - data: full context with text field (for telegram/chat)
-      const outputField = params?.outputField || 'text';
-      const outputData = { ...(typeof data === 'object' ? data : {}), [outputField]: result };
-
-      // Attach inline keyboard if configured
-      if (params?.replyMarkup) {
-        try {
-          outputData.reply_markup = JSON.parse(params.replyMarkup);
-        } catch (e) {
-          console.warn('[template] ⚠️ Invalid replyMarkup JSON:', e.message);
-        }
-      }
-
-      return {
-        result,
-        data: outputData,
-      };
-    },
-  },
-};

package/vendor/symbiote-node/engine/packs/transform/timeline-build.handler.js

@@ -1,399 +0,0 @@
-/**
- * transform/timeline-build — Whisper + beats → timeline segments
- *
- * Combines word timestamps from ai/whisper with beat data from ai/beat-detect
- * to produce a continuous timeline of segments with 100% coverage.
- *
- * Core logic:
- * 1. Build phrases from whisper words (punctuation-based splitting)
- * 2. Fill gaps between phrases with beat-snapped segments
- * 3. Enforce minimum/maximum segment duration (merge/split)
- * 4. Calculate coverage statistics
- *
- * Simplified port of TimelineGenerator from
- * Mr-Computer/modules/ai-music-video/src/services/timeline-generator.js
- *
- * @module agi-graph/packs/transform/timeline-build
- */
-
-export default {
-  type: 'transform/timeline-build',
-  category: 'transform',
-  icon: 'view_timeline',
-
-  driver: {
-    description: 'Whisper words + beat data → timeline segments with 100% coverage',
-    inputs: [
-      { name: 'whisperData', type: 'any' },
-      { name: 'beatData', type: 'any' },
-    ],
-    outputs: [
-      { name: 'segments', type: 'any' },
-      { name: 'stats', type: 'any' },
-      { name: 'error', type: 'string' },
-    ],
-    params: {
-      minSegmentDuration: { type: 'number', default: 1.8, description: 'Min segment duration (seconds)' },
-      maxSegmentDuration: { type: 'number', default: 5.0, description: 'Max segment duration (seconds)' },
-      shortMergeThreshold: { type: 'number', default: 1.2, description: 'Merge lyrics segments shorter than this' },
-      gapType: { type: 'string', default: 'beat', description: 'Type label for gap-fill segments' },
-    },
-  },
-
-  lifecycle: {
-    validate: (inputs) => {
-      if (!inputs.whisperData) return false;
-      return true;
-    },
-
-    cacheKey: (inputs, params) => {
-      const wd = inputs.whisperData;
-      const bd = inputs.beatData;
-      return `timeline:${wd.duration || 0}:${bd?.tempo || 0}:${params.minSegmentDuration}`;
-    },
-
-    execute: async (inputs, params) => {
-      try {
-        const { whisperData, beatData } = inputs;
-        const words = whisperData.words || [];
-        const duration = whisperData.duration || beatData?.duration || 0;
-        const beats = beatData?.beats || [];
-
-        if (words.length === 0) {
-          return { segments: null, stats: null, error: 'No whisper words provided' };
-        }
-
-        // Step 1: Build phrases from words
-        let segments = buildPhrases(words);
-
-        // Step 2: Fill gaps with beat-snapped segments
-        segments = fillGaps(segments, beats, duration, params);
-
-        // Step 3: Remove overlaps
-        segments = removeOverlaps(segments);
-
-        // Step 4: Merge short segments
-        segments = mergeShort(segments, params.shortMergeThreshold || 1.2);
-
-        // Step 5: Enforce min duration
-        segments = enforceMinDuration(segments, params.minSegmentDuration || 1.8);
-
-        // Step 6: Cap max duration
-        segments = capMaxDuration(segments, params.maxSegmentDuration || 5.0);
-
-        // Sort final
-        segments.sort((a, b) => a.start - b.start);
-
-        // Stats
-        const stats = calculateStats(segments, duration);
-
-        return { segments, stats, error: null };
-      } catch (err) {
-        return { segments: null, stats: null, error: err.message };
-      }
-    },
-  },
-};
-
-/**
- * Build phrases from whisper words using punctuation-based splitting
- * @param {Array<{word: string, start: number, end: number}>} words
- * @returns {Array<{start: number, end: number, text: string, type: string, wordCount: number}>}
- */
-function buildPhrases(words) {
-  const phrases = [];
-  let current = null;
-
-  for (const w of words) {
-    if (!current) {
-      current = {
-        start: w.start,
-        end: w.end,
-        words: [w.word],
-        type: 'lyrics',
-      };
-    } else {
-      current.end = w.end;
-      current.words.push(w.word);
-    }
-
-    // Split on sentence endings, commas, or long pauses
-    const endsWithPunct = /[.!?;]$/.test(w.word);
-    const nextWord = words[words.indexOf(w) + 1];
-    const hasGap = nextWord && (nextWord.start - w.end > 0.8);
-
-    if (endsWithPunct || hasGap || current.words.length >= 12) {
-      phrases.push({
-        start: current.start,
-        end: current.end,
-        text: current.words.join(' '),
-        type: 'lyrics',
-        wordCount: current.words.length,
-      });
-      current = null;
-    }
-  }
-
-  // Close last phrase
-  if (current && current.words.length > 0) {
-    phrases.push({
-      start: current.start,
-      end: current.end,
-      text: current.words.join(' '),
-      type: 'lyrics',
-      wordCount: current.words.length,
-    });
-  }
-
-  return phrases;
-}
-
-/**
- * Snap a time to the nearest beat
- * @param {number} time - Seconds
- * @param {number[]} beats - Beat timestamps
- * @returns {number} Snapped time
- */
-function snapToBeat(time, beats) {
-  if (!beats || beats.length === 0) return time;
-
-  let closest = beats[0];
-  let minDist = Math.abs(beats[0] - time);
-
-  for (const beat of beats) {
-    const dist = Math.abs(beat - time);
-    if (dist < minDist) {
-      minDist = dist;
-      closest = beat;
-    }
-    if (beat > time + minDist) break;
-  }
-
-  // Only snap if within 0.3s of a beat
-  return minDist < 0.3 ? closest : time;
-}
-
-/**
- * Fill gaps between segments with beat-snapped segments
- * @param {Array} segments
- * @param {number[]} beats
- * @param {number} duration
- * @param {Object} params
- * @returns {Array}
- */
-function fillGaps(segments, beats, duration, params) {
-  if (segments.length === 0) return segments;
-
-  const result = [];
-  const gapType = params.gapType || 'beat';
-
-  // Gap at start?
-  if (segments[0].start > 0.1) {
-    result.push({
-      start: 0,
-      end: snapToBeat(segments[0].start, beats),
-      text: '',
-      type: gapType,
-      wordCount: 0,
-    });
-  }
-
-  for (let i = 0; i < segments.length; i++) {
-    result.push(segments[i]);
-
-    // Gap to next segment?
-    const next = segments[i + 1];
-    if (next) {
-      const gapStart = segments[i].end;
-      const gapEnd = next.start;
-      const gapSize = gapEnd - gapStart;
-
-      if (gapSize > 0.2) {
-        result.push({
-          start: snapToBeat(gapStart, beats),
-          end: snapToBeat(gapEnd, beats),
-          text: '',
-          type: gapType,
-          wordCount: 0,
-        });
-      }
-    }
-  }
-
-  // Gap at end?
-  const lastEnd = segments[segments.length - 1].end;
-  if (duration > 0 && duration - lastEnd > 0.2) {
-    result.push({
-      start: snapToBeat(lastEnd, beats),
-      end: duration,
-      text: '',
-      type: gapType,
-      wordCount: 0,
-    });
-  }
-
-  return result;
-}
-
-/**
- * Remove overlapping segments (trim shorter one)
- * @param {Array} segments
- * @returns {Array}
- */
-function removeOverlaps(segments) {
-  if (segments.length < 2) return segments;
-
-  segments.sort((a, b) => a.start - b.start);
-
-  for (let i = 1; i < segments.length; i++) {
-    const prev = segments[i - 1];
-    const curr = segments[i];
-
-    if (curr.start < prev.end) {
-      // Overlap: trim the gap segment, or split at midpoint
-      if (prev.type !== 'lyrics' && curr.type === 'lyrics') {
-        prev.end = curr.start;
-      } else if (prev.type === 'lyrics' && curr.type !== 'lyrics') {
-        curr.start = prev.end;
-      } else {
-        const mid = (prev.end + curr.start) / 2;
-        prev.end = mid;
-        curr.start = mid;
-      }
-    }
-  }
-
-  // Remove zero/negative duration segments
-  return segments.filter(s => s.end - s.start > 0.05);
-}
-
-/**
- * Merge short lyrics segments into neighbors
- * @param {Array} segments
- * @param {number} threshold
- * @returns {Array}
- */
-function mergeShort(segments, threshold) {
-  if (segments.length < 2) return segments;
-
-  const result = [segments[0]];
-
-  for (let i = 1; i < segments.length; i++) {
-    const curr = segments[i];
-    const prev = result[result.length - 1];
-    const currDuration = curr.end - curr.start;
-
-    // Merge short lyrics into previous
-    if (curr.type === 'lyrics' && currDuration < threshold && prev.type === 'lyrics') {
-      prev.end = curr.end;
-      prev.text = prev.text + ' ' + curr.text;
-      prev.wordCount = (prev.wordCount || 0) + (curr.wordCount || 0);
-    } else {
-      result.push(curr);
-    }
-  }
-
-  return result;
-}
-
-/**
- * Enforce minimum duration by merging
- * @param {Array} segments
- * @param {number} minDuration
- * @returns {Array}
- */
-function enforceMinDuration(segments, minDuration) {
-  if (segments.length < 2) return segments;
-
-  const result = [segments[0]];
-
-  for (let i = 1; i < segments.length; i++) {
-    const prev = result[result.length - 1];
-    const prevDuration = prev.end - prev.start;
-
-    if (prevDuration < minDuration) {
-      // Extend previous to absorb current
-      prev.end = segments[i].end;
-      if (segments[i].text) {
-        prev.text = (prev.text ? prev.text + ' ' : '') + segments[i].text;
-      }
-      if (segments[i].type === 'lyrics') prev.type = 'lyrics';
-    } else {
-      result.push(segments[i]);
-    }
-  }
-
-  return result;
-}
-
-/**
- * Cap segments at max duration by splitting evenly
- * @param {Array} segments
- * @param {number} maxDuration
- * @returns {Array}
- */
-function capMaxDuration(segments, maxDuration) {
-  const result = [];
-
-  for (const seg of segments) {
-    const duration = seg.end - seg.start;
-
-    if (duration <= maxDuration) {
-      result.push(seg);
-      continue;
-    }
-
-    // Split evenly
-    const parts = Math.ceil(duration / maxDuration);
-    const partDuration = duration / parts;
-
-    for (let i = 0; i < parts; i++) {
-      result.push({
-        ...seg,
-        start: seg.start + i * partDuration,
-        end: seg.start + (i + 1) * partDuration,
-        text: i === 0 ? seg.text : '',
-        _splitPart: i + 1,
-        _splitTotal: parts,
-      });
-    }
-  }
-
-  return result;
-}
-
-/**
- * Calculate timeline coverage statistics
- * @param {Array} segments
- * @param {number} audioDuration
- * @returns {Object}
- */
-function calculateStats(segments, audioDuration) {
-  const totalSegments = segments.length;
-  const lyricsSegments = segments.filter(s => s.type === 'lyrics').length;
-  const gapSegments = totalSegments - lyricsSegments;
-
-  const coveredDuration = segments.reduce((sum, s) => sum + (s.end - s.start), 0);
-  const lyricsDuration = segments
-    .filter(s => s.type === 'lyrics')
-    .reduce((sum, s) => sum + (s.end - s.start), 0);
-
-  const coverage = audioDuration > 0
-    ? Math.round((coveredDuration / audioDuration) * 100)
-    : 0;
-
-  const avgDuration = totalSegments > 0
-    ? Math.round((coveredDuration / totalSegments) * 100) / 100
-    : 0;
-
-  return {
-    totalSegments,
-    lyricsSegments,
-    gapSegments,
-    coveredDuration: Math.round(coveredDuration * 100) / 100,
-    audioDuration: Math.round(audioDuration * 100) / 100,
-    coverage,
-    lyricsDuration: Math.round(lyricsDuration * 100) / 100,
-    avgDuration,
-  };
-}

package/vendor/symbiote-node/engine/packs/util/delay.handler.js

@@ -1,39 +0,0 @@
-/**
- * util/delay — Pause pipeline execution
- *
- * Waits for specified milliseconds, then passes input value through.
- * Useful for rate limiting, animation timing, and API cooldowns.
- *
- * @module agi-graph/packs/util/delay
- */
-
-export default {
-  type: 'util/delay',
-  category: 'util',
-  icon: 'hourglass_empty',
-
-  driver: {
-    description: 'Pause execution for N milliseconds, pass value through',
-    inputs: [
-      { name: 'value', type: 'any' },
-    ],
-    outputs: [
-      { name: 'value', type: 'any' },
-    ],
-    params: {
-      ms: { type: 'int', default: 1000, description: 'Delay in milliseconds' },
-    },
-  },
-
-  lifecycle: {
-    validate: () => true,
-
-    // Never cache delays
-    cacheKey: null,
-
-    execute: async (inputs, params) => {
-      await new Promise(resolve => setTimeout(resolve, params.ms || 1000));
-      return { value: inputs.value };
-    },
-  },
-};

package/vendor/symbiote-node/engine/packs/util/log.handler.js

@@ -1,44 +0,0 @@
-/**
- * util/log — Console logger passthrough
- *
- * Logs input value to console and passes it through unchanged.
- * Useful for debugging pipelines.
- *
- * @module symbiote-node/packs/util/log */
-
-export default {
-  type: 'util/log',
-  category: 'util',
-  icon: 'terminal',
-
-  driver: {
-    description: 'Log value to console and pass through',
-    inputs: [
-      { name: 'value', type: 'any' },
-    ],
-    outputs: [
-      { name: 'value', type: 'any' },
-    ],
-    params: {
-      label: { type: 'string', default: '', description: 'Log label prefix' },
-      level: { type: 'string', default: 'info', description: 'Log level: log | info | warn | error' },
-    },
-  },
-
-  lifecycle: {
-    validate: () => true,
-    cacheKey: null,
-
-    execute: async (inputs, params) => {
-      const label = params.label ? `[${params.label}]` : '[symbiote-node]';      const method = params.level || 'info';
-
-      const logFn = console[method] || console.log;
-      logFn(label, typeof inputs.value === 'object'
-        ? JSON.stringify(inputs.value, null, 2)
-        : inputs.value
-      );
-
-      return { value: inputs.value };
-    },
-  },
-};