project-graph-mcp 2.3.0 → 2.3.2

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

@@ -0,0 +1,191 @@
+/**
+ * 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

@@ -0,0 +1,67 @@
+/**
+ * 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

@@ -0,0 +1,281 @@
+/**
+ * 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

@@ -0,0 +1,160 @@
+/**
+ * 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}` };
+    },
+  },
+};