project-graph-mcp 2.3.2 → 2.4.1

package/vendor/symbiote-node/engine/packs/ai/whisper.handler.js

@@ -1,191 +0,0 @@
-/**
- * ai/whisper — Audio transcription with word-level timestamps
- *
- * Two modes:
- * - SSH: uploads audio to remote server via scp, runs Whisper via SSH
- * - HTTP: sends audio to a Whisper HTTP endpoint (e.g., faster-whisper-server)
- *
- * SSH remote config from Mr-Computer/modules/ai-music-video/whisper-ssh.js:
- *   Host: mr-agent@mr-agent.rnd-pro.com
- *   Venv: /home/mr-agent/automations/argentine-spanish-bot/venv
- *   Script: utils/whisper-word-timing.py
- *
- * @module agi-graph/packs/ai/whisper
- */
-
-import { execSync } from 'child_process';
-import { promises as fs } from 'fs';
-import path from 'path';
-
-export default {
-  type: 'ai/whisper',
-  category: 'ai',
-  icon: 'hearing',
-
-  driver: {
-    description: 'Audio transcription with word-level timestamps (SSH or HTTP mode)',
-    inputs: [
-      { name: 'audioPath', type: 'string' },
-    ],
-    outputs: [
-      { name: 'text', type: 'string' },
-      { name: 'words', type: 'any' },
-      { name: 'duration', type: 'number' },
-      { name: 'error', type: 'string' },
-    ],
-    params: {
-      mode: { type: 'string', default: 'ssh', description: 'ssh | http' },
-      language: { type: 'string', default: 'es', description: 'Language code' },
-      model: { type: 'string', default: 'medium', description: 'Whisper model: tiny, base, small, medium, large-v3' },
-      device: { type: 'string', default: 'cuda', description: 'cuda | cpu' },
-      // SSH params
-      remoteHost: { type: 'string', default: 'mr-agent@mr-agent.rnd-pro.com', description: 'SSH host' },
-      remotePath: { type: 'string', default: '/home/mr-agent/automations/argentine-spanish-bot', description: 'Remote project path' },
-      remoteVenv: { type: 'string', default: '/home/mr-agent/automations/argentine-spanish-bot/venv', description: 'Remote Python venv' },
-      // HTTP params
-      endpoint: { type: 'string', default: 'http://localhost:5001', description: 'Whisper HTTP endpoint' },
-      timeout: { type: 'int', default: 300000, description: 'Max wait time (ms)' },
-    },
-  },
-
-  lifecycle: {
-    validate: (inputs) => {
-      if (!inputs.audioPath) return false;
-      return true;
-    },
-
-    cacheKey: (inputs, params) =>
-      `whisper:${params.mode}:${params.model}:${inputs.audioPath}`,
-
-    execute: async (inputs, params) => {
-      const { audioPath } = inputs;
-      const mode = params.mode || process.env.WHISPER_MODE || 'ssh';
-
-      if (mode === 'http') {
-        return executeHTTP(audioPath, params);
-      }
-      return executeSSH(audioPath, params);
-    },
-  },
-};
-
-/**
- * SSH mode: scp upload → remote python exec → parse JSON output
- * @param {string} audioPath - Local audio file path
- * @param {Object} params - Node params
- * @returns {Promise<Object>} Result with text, words, duration
- */
-async function executeSSH(audioPath, params) {
-  const host = params.remoteHost || process.env.WHISPER_REMOTE_HOST || 'mr-agent@mr-agent.rnd-pro.com';
-  const remotePath = params.remotePath || process.env.WHISPER_REMOTE_PATH || '/home/mr-agent/automations/argentine-spanish-bot';
-  const venv = params.remoteVenv || process.env.WHISPER_REMOTE_VENV || `${remotePath}/venv`;
-  const model = params.model || process.env.WHISPER_MODEL || 'medium';
-  const device = params.device || process.env.WHISPER_DEVICE || 'cuda';
-  const language = params.language || 'es';
-  const remoteTmpDir = '/tmp/agi-graph-whisper';
-
-  try {
-    // Verify file exists
-    await fs.access(audioPath);
-
-    const filename = path.basename(audioPath);
-    const remoteAudioPath = `${remoteTmpDir}/${filename}`;
-
-    // Ensure remote dir
-    execSync(`ssh ${host} "mkdir -p ${remoteTmpDir}"`, {
-      encoding: 'utf-8',
-      stdio: 'pipe',
-      timeout: 10000,
-    });
-
-    // Upload audio
-    execSync(`scp "${audioPath}" "${host}:${remoteAudioPath}"`, {
-      encoding: 'utf-8',
-      stdio: 'pipe',
-      timeout: 60000,
-    });
-
-    try {
-      // Run Whisper
-      const pythonCmd = `${venv}/bin/python3`;
-      const whisperScript = `${remotePath}/utils/whisper-word-timing.py`;
-
-      const cmd = `"${pythonCmd}" "${whisperScript}" "${remoteAudioPath}" "${language}" --model "${model}" --device "${device}"`;
-      const fullCmd = `ssh ${host} '${cmd}'`;
-
-      const output = execSync(fullCmd, {
-        encoding: 'utf-8',
-        maxBuffer: 50 * 1024 * 1024,
-        timeout: params.timeout || 300000,
-      });
-
-      const words = JSON.parse(output);
-      const text = words.map(w => w.word).join(' ');
-      const duration = words.length > 0
-        ? words[words.length - 1].end
-        : 0;
-
-      return { text, words, duration, error: null };
-
-    } finally {
-      // Cleanup remote file
-      try {
-        execSync(`ssh ${host} "rm -f ${remoteAudioPath}"`, {
-          encoding: 'utf-8',
-          stdio: 'pipe',
-          timeout: 5000,
-        });
-      } catch { /* ignore */ }
-    }
-
-  } catch (err) {
-    return { text: null, words: null, duration: 0, error: err.message };
-  }
-}
-
-/**
- * HTTP mode: POST audio to Whisper endpoint via FormData
- * @param {string} audioPath - Local audio file path
- * @param {Object} params - Node params
- * @returns {Promise<Object>} Result with text, words, duration
- */
-async function executeHTTP(audioPath, params) {
-  const endpoint = params.endpoint || process.env.WHISPER_ENDPOINT || 'http://localhost:5001';
-  const language = params.language || 'es';
-
-  try {
-    const audioBuffer = await fs.readFile(audioPath);
-    const blob = new Blob([audioBuffer], { type: 'audio/wav' });
-
-    const formData = new FormData();
-    formData.append('file', blob, path.basename(audioPath));
-    formData.append('language', language);
-    formData.append('word_timestamps', 'true');
-
-    if (params.model) {
-      formData.append('model', params.model);
-    }
-
-    const response = await fetch(`${endpoint}/transcribe`, {
-      method: 'POST',
-      body: formData,
-      signal: AbortSignal.timeout(params.timeout || 300000),
-    });
-
-    if (!response.ok) {
-      return { text: null, words: null, duration: 0, error: `Whisper API error: ${response.status}` };
-    }
-
-    const result = await response.json();
-    const words = result.words || [];
-    const text = result.text || words.map(w => w.word).join(' ');
-    const duration = words.length > 0
-      ? words[words.length - 1].end
-      : 0;
-
-    return { text, words, duration, error: null };
-
-  } catch (err) {
-    return { text: null, words: null, duration: 0, error: err.message };
-  }
-}

package/vendor/symbiote-node/engine/packs/data/db-query.handler.js

@@ -1,67 +0,0 @@
-/**
- * data/db-query — Universal SQL query node
- *
- * Executes a parameterized SQL query against the connected database.
- * Parameters are extracted from input data fields specified in params.paramFields.
- *
- * This is a generic node — the DB connection is injected by the host application
- * via context.db (postgres tagged template instance).
- *
- * @module symbiote-node/packs/data/db-query
- */
-
-export default {
-  type: 'data/db-query',
-  category: 'data',
-  icon: 'database',
-
-  driver: {
-    description: 'Execute SQL query with parameters from input data',
-    inputs: [
-      { name: 'data', type: 'any' },
-    ],
-    outputs: [
-      { name: 'rows', type: 'any' },
-      { name: 'data', type: 'any' },
-    ],
-    params: {
-      query: { type: 'text', default: '', description: 'SQL query with $1, $2... placeholders' },
-      paramFields: { type: 'string', default: '', description: 'Comma-separated field names from input data to use as query params' },
-      outputField: { type: 'string', default: 'queryResult', description: 'Field name to store rows in data output' },
-    },
-  },
-
-  lifecycle: {
-    validate: (inputs, params) => {
-      return !!params.query;
-    },
-
-    execute: async (inputs, params, context) => {
-      const data = inputs.data || {};
-      const query = params.query;
-
-      // Extract param values from input data
-      const paramNames = (params.paramFields || '')
-        .split(',')
-        .map((s) => s.trim())
-        .filter(Boolean);
-      const paramValues = paramNames.map((field) => data[field]);
-
-      // Execute via context.db (injected by host)
-      if (!context?.db) {
-        return {
-          rows: [],
-          data: { ...data, [params.outputField || 'queryResult']: [], error: 'No DB context' },
-        };
-      }
-
-      const rows = await context.db.unsafe(query, paramValues);
-      const outputField = params.outputField || 'queryResult';
-
-      return {
-        rows: [...rows],
-        data: { ...data, [outputField]: [...rows] },
-      };
-    },
-  },
-};

package/vendor/symbiote-node/engine/packs/data/news-accumulate.handler.js

@@ -1,281 +0,0 @@
-/**
- * data/news-accumulate — News Accumulator
- *
- * Collects and stores raw news items with deduplication, filtering,
- * period management, and category statistics. Supports horoscope
- * and international news filtering for Argentina-focused content.
- *
- * Ported from Mr-Computer/automations/argentine-spanish-bot/src/services/news-accumulator.js
- *
- * @module agi-graph/packs/data/news-accumulate
- */
-
-import { readFile, writeFile, mkdir } from 'node:fs/promises';
-import path from 'node:path';
-
-// Non-local patterns to filter out
-const NON_LOCAL_PATTERNS = ['en eeuu', 'desde estados unidos'];
-const HOROSCOPE_PATTERNS = ['horóscopo', 'horoscopo', 'astrolog', 'signo del zodiaco', 'signo del zodíaco'];
-
-/**
- * Simple hash for news dedup
- * @param {string} str
- * @returns {string}
- */
-function hashString(str) {
-  let hash = 0;
-  for (let i = 0; i < str.length; i++) {
-    const chr = str.charCodeAt(i);
-    hash = ((hash << 5) - hash) + chr;
-    hash |= 0;
-  }
-  return Math.abs(hash).toString(36);
-}
-
-/**
- * Generate unique ID for a news item
- * @param {Object} item
- * @returns {string}
- */
-function generateId(item) {
-  const source = item.link || item.url || '';
-  const title = item.title || '';
-  return hashString(`${title}:${source}`);
-}
-
-/**
- * Standardize a news item
- * @param {Object} item
- * @returns {Object}
- */
-function standardizeItem(item) {
-  return {
-    id: item.id || generateId(item),
-    title: item.title || '',
-    description: item.description || item.content || '',
-    link: item.link || item.url || '',
-    category: item.category || { id: 'general', name: 'General' },
-    source: item.source || '',
-    image: item.image || null,
-    pubDate: item.pubDate || new Date().toISOString(),
-    addedAt: new Date().toISOString(),
-    processed: false,
-  };
-}
-
-/**
- * Filter out international news
- * @param {Array} items
- * @returns {Array}
- */
-function filterArgentinaOnly(items) {
-  return items.filter(item => {
-    const text = `${item.title} ${item.description}`.toLowerCase();
-    return !NON_LOCAL_PATTERNS.some(p => text.includes(p));
-  });
-}
-
-/**
- * Filter out horoscope content
- * @param {Array} items
- * @returns {Array}
- */
-function filterOutHoroscopes(items) {
-  return items.filter(item => {
-    const text = `${item.title} ${item.description}`.toLowerCase();
-    return !HOROSCOPE_PATTERNS.some(p => text.includes(p));
-  });
-}
-
-/**
- * Load stored data from file
- * @param {string} storePath
- * @returns {Promise<Object>}
- */
-async function loadStore(storePath) {
-  try {
-    const data = await readFile(storePath, 'utf-8');
-    return JSON.parse(data);
-  } catch {
-    return {
-      news: [],
-      periodStart: new Date().toISOString(),
-      categoryCounts: {},
-      processedIds: [],
-    };
-  }
-}
-
-/**
- * Save data to file
- * @param {string} storePath
- * @param {Object} data
- */
-async function saveStore(storePath, data) {
-  await mkdir(path.dirname(storePath), { recursive: true });
-  await writeFile(storePath, JSON.stringify(data, null, 2));
-}
-
-// ─── Handler Definition ────────────────────────────────────────────────
-
-export default {
-  type: 'data/news-accumulate',
-  category: 'data',
-  icon: 'newspaper',
-
-  driver: {
-    description: 'Collect and store news with dedup, filtering, periods, and category stats',
-    inputs: [
-      { name: 'storePath', type: 'string' },
-    ],
-    outputs: [
-      { name: 'result', type: 'any' },
-      { name: 'error', type: 'string' },
-    ],
-    params: {
-      operation: { type: 'string', default: 'get', description: 'Operation: add | get | mark-processed | new-period | stats' },
-      // add
-      newsItem: { type: 'any', default: null, description: 'News item to add' },
-      newsItems: { type: 'any', default: null, description: 'Array of news items to add (batch)' },
-      // get filters
-      categories: { type: 'any', default: null, description: 'Filter by categories array' },
-      since: { type: 'string', default: null, description: 'Get news since ISO date' },
-      filterLocal: { type: 'boolean', default: false, description: 'Filter out non-local (international) news' },
-      filterHoroscopes: { type: 'boolean', default: true, description: 'Filter out horoscope content' },
-      maxItems: { type: 'int', default: 100, description: 'Maximum items to return' },
-      // mark-processed
-      newsIds: { type: 'any', default: null, description: 'Array of news IDs to mark processed' },
-    },
-  },
-
-  lifecycle: {
-    validate: (inputs) => {
-      return typeof inputs.storePath === 'string' && inputs.storePath.length > 0;
-    },
-
-    cacheKey: () => null, // mutable state
-
-    execute: async (inputs, params) => {
-      const { storePath } = inputs;
-      const { operation } = params;
-
-      try {
-        const store = await loadStore(storePath);
-
-        switch (operation) {
-          case 'add': {
-            const itemsToAdd = params.newsItems
-              ? params.newsItems
-              : params.newsItem
-                ? [params.newsItem]
-                : [];
-
-            if (itemsToAdd.length === 0) return { error: 'No items to add' };
-
-            const existingIds = new Set(store.news.map(n => n.id));
-            let added = 0;
-
-            for (const raw of itemsToAdd) {
-              const item = standardizeItem(raw);
-              if (existingIds.has(item.id)) continue;
-
-              store.news.push(item);
-              existingIds.add(item.id);
-              added++;
-
-              // Update category counts
-              const catId = typeof item.category === 'object' ? item.category.id : item.category;
-              store.categoryCounts[catId] = (store.categoryCounts[catId] || 0) + 1;
-            }
-
-            await saveStore(storePath, store);
-            return { result: { added, total: store.news.length, duplicatesSkipped: itemsToAdd.length - added } };
-          }
-
-          case 'get': {
-            let items = store.news.filter(n => !n.processed);
-
-            // Date filter
-            if (params.since) {
-              const sinceDate = new Date(params.since);
-              items = items.filter(n => new Date(n.addedAt) >= sinceDate);
-            }
-
-            // Category filter
-            if (Array.isArray(params.categories) && params.categories.length > 0) {
-              items = items.filter(n => {
-                const catId = typeof n.category === 'object' ? n.category.id : n.category;
-                return params.categories.includes(catId);
-              });
-            }
-
-            // Content filters
-            if (params.filterLocal) items = filterArgentinaOnly(items);
-            if (params.filterHoroscopes) items = filterOutHoroscopes(items);
-
-            items = items.slice(0, params.maxItems);
-
-            return { result: { items, count: items.length } };
-          }
-
-          case 'mark-processed': {
-            if (!Array.isArray(params.newsIds)) return { error: 'newsIds array is required' };
-
-            const idsSet = new Set(params.newsIds);
-            let marked = 0;
-
-            for (const item of store.news) {
-              if (idsSet.has(item.id) && !item.processed) {
-                item.processed = true;
-                item.processedAt = new Date().toISOString();
-                marked++;
-              }
-            }
-
-            store.processedIds.push(...params.newsIds);
-            await saveStore(storePath, store);
-            return { result: { marked, total: params.newsIds.length } };
-          }
-
-          case 'new-period': {
-            const archived = {
-              periodStart: store.periodStart,
-              periodEnd: new Date().toISOString(),
-              itemCount: store.news.length,
-              categoryCounts: { ...store.categoryCounts },
-            };
-
-            store.news = [];
-            store.periodStart = new Date().toISOString();
-            store.categoryCounts = {};
-            store.processedIds = [];
-
-            await saveStore(storePath, store);
-            return { result: { archived, message: 'New period started' } };
-          }
-
-          case 'stats': {
-            const total = store.news.length;
-            const processed = store.news.filter(n => n.processed).length;
-            const unprocessed = total - processed;
-
-            return {
-              result: {
-                total,
-                processed,
-                unprocessed,
-                periodStart: store.periodStart,
-                categoryCounts: store.categoryCounts,
-              },
-            };
-          }
-
-          default:
-            return { error: `Unknown operation: ${operation}` };
-        }
-      } catch (err) {
-        return { error: `news-accumulate ${operation} failed: ${err.message}` };
-      }
-    },
-  },
-};

package/vendor/symbiote-node/engine/packs/data/personas.handler.js

@@ -1,160 +0,0 @@
-/**
- * data/personas — Character persona registry for TTS pipelines
- *
- * Manages character presets with voice settings, personality descriptions,
- * and audio reference samples. Used as a data source node that feeds
- * ai/tts with correct speaker/voice parameters.
- *
- * Persona structure (from Mr-Computer/argentine-spanish-bot):
- *   id, name, personality, voiceInstruct, speaker (Qwen3 ID),
- *   refAudio (per-language samples), pan (stereo position)
- *
- * Operations:
- *   get     — get persona by ID
- *   list    — list all personas (optionally filtered)
- *   random  — pick N random personas
- *
- * @module agi-graph/packs/data/personas
- */
-
-/** @typedef {Object} Persona
- * @property {string} id - Unique identifier
- * @property {string} name - Display name
- * @property {string} personality - Character description for AI prompts
- * @property {string} voiceInstruct - Emotion/style instruction for TTS
- * @property {string} speaker - Qwen3-TTS speaker ID (ryan, vivian, etc.)
- * @property {Object<string, string>} [refAudio] - Per-language voice reference paths
- * @property {number} [pan] - Stereo position (-1.0 left to 1.0 right)
- * @property {string} [gender] - male | female
- * @property {string} [type] - normal | meme | dj
- */
-
-/**
- * Built-in persona presets (from radio-dj-config.js)
- * @type {Persona[]}
- */
-const BUILT_IN_PRESETS = [
-  {
-    id: 'dj_matias',
-    name: 'Matías',
-    personality: 'Energetic morning host, asks probing questions, uses "che" frequently',
-    voiceInstruct: 'Enthusiastic and dynamic, curious tone',
-    speaker: 'ryan',
-    pan: -0.2,
-    gender: 'male',
-    type: 'dj',
-  },
-  {
-    id: 'dj_lucia',
-    name: 'Lucía',
-    personality: 'Analytical co-host, provides context and facts, thoughtful responses',
-    voiceInstruct: 'Clear articulate tone, warm and engaging',
-    speaker: 'vivian',
-    pan: 0.2,
-    gender: 'female',
-    type: 'dj',
-  },
-  {
-    id: 'dj_carlos',
-    name: 'Carlos',
-    personality: 'Veteran journalist, offers historical perspective, calm authority',
-    voiceInstruct: 'Deep calm authoritative voice, measured pace',
-    speaker: 'ryan',
-    pan: -0.1,
-    gender: 'male',
-    type: 'dj',
-  },
-  {
-    id: 'dj_sofia',
-    name: 'Sofía',
-    personality: 'Young reporter, brings fresh perspectives, occasionally interrupts with excitement',
-    voiceInstruct: 'Youthful energetic voice, sometimes excited',
-    speaker: 'vivian',
-    pan: 0.1,
-    gender: 'female',
-    type: 'dj',
-  },
-];
-
-export default {
-  type: 'data/personas',
-  category: 'data',
-  icon: 'groups',
-
-  driver: {
-    description: 'Character persona registry — voice presets with personality for TTS',
-    inputs: [
-      { name: 'personaId', type: 'string' },
-    ],
-    outputs: [
-      { name: 'persona', type: 'any' },
-      { name: 'personas', type: 'any' },
-      { name: 'error', type: 'string' },
-    ],
-    params: {
-      operation: { type: 'string', default: 'get', description: 'get | list | random' },
-      count: { type: 'int', default: 2, description: 'Number of personas for random operation' },
-      filterGender: { type: 'string', default: '', description: 'Filter by gender: male | female' },
-      filterType: { type: 'string', default: '', description: 'Filter by type: dj | normal | meme' },
-      customPresets: { type: 'any', default: null, description: 'Custom persona array (overrides built-in)' },
-    },
-  },
-
-  lifecycle: {
-    validate: (inputs, params) => {
-      const op = params?.operation || 'get';
-      if (op === 'get' && !inputs.personaId) return false;
-      return true;
-    },
-
-    cacheKey: (inputs, params) => {
-      const op = params.operation || 'get';
-      if (op === 'get') return `personas:get:${inputs.personaId}`;
-      if (op === 'random') return null; // Never cache random
-      return `personas:list:${params.filterGender}:${params.filterType}`;
-    },
-
-    execute: async (inputs, params) => {
-      const presets = params.customPresets || BUILT_IN_PRESETS;
-      const op = params.operation || 'get';
-
-      if (op === 'get') {
-        const persona = presets.find(p => p.id === inputs.personaId);
-        if (!persona) {
-          return { persona: null, personas: null, error: `Persona not found: ${inputs.personaId}` };
-        }
-        return { persona, personas: null, error: null };
-      }
-
-      if (op === 'list') {
-        let filtered = [...presets];
-        if (params.filterGender) {
-          filtered = filtered.filter(p => p.gender === params.filterGender);
-        }
-        if (params.filterType) {
-          filtered = filtered.filter(p => p.type === params.filterType);
-        }
-        return { persona: null, personas: filtered, error: null };
-      }
-
-      if (op === 'random') {
-        let pool = [...presets];
-        if (params.filterGender) {
-          pool = pool.filter(p => p.gender === params.filterGender);
-        }
-        if (params.filterType) {
-          pool = pool.filter(p => p.type === params.filterType);
-        }
-        // Fisher-Yates shuffle
-        for (let i = pool.length - 1; i > 0; i--) {
-          const j = Math.floor(Math.random() * (i + 1));
-          [pool[i], pool[j]] = [pool[j], pool[i]];
-        }
-        const selected = pool.slice(0, Math.min(params.count || 2, pool.length));
-        return { persona: selected[0] || null, personas: selected, error: null };
-      }
-
-      return { persona: null, personas: null, error: `Unknown operation: ${op}` };
-    },
-  },
-};