project-graph-mcp 2.3.0 → 2.3.2

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

@@ -0,0 +1,215 @@
+/**
+ * ai/beat-detect — Audio beat detection via librosa (SSH)
+ *
+ * Analyzes audio files to extract:
+ * - Beat timestamps and tempo (BPM)
+ * - Waveform peaks (configurable resolution)
+ * - Energy contour
+ * - Quiet zones (silence detection)
+ * - Strong onsets (transient detection)
+ *
+ * Uses Python librosa library on remote server via SSH.
+ * Based on Mr-Computer/modules/ai-music-video beat-detector-ssh.js
+ *
+ * Remote: mr-agent@mr-agent.rnd-pro.com
+ * Script: beat-detection.py (uploaded automatically)
+ * Venv:   /home/mr-agent/automations/argentine-spanish-bot/venv
+ *
+ * @module agi-graph/packs/ai/beat-detect
+ */
+
+import { execSync } from 'child_process';
+import { promises as fs } from 'fs';
+import path from 'path';
+import os from 'os';
+
+export default {
+  type: 'ai/beat-detect',
+  category: 'ai',
+  icon: 'graphic_eq',
+
+  driver: {
+    description: 'Audio beat detection via librosa — beats, tempo, peaks, energy',
+    inputs: [
+      { name: 'audioPath', type: 'string' },
+    ],
+    outputs: [
+      { name: 'beats', type: 'any' },
+      { name: 'tempo', type: 'number' },
+      { name: 'peaks', type: 'any' },
+      { name: 'energy', type: 'any' },
+      { name: 'quietZones', type: 'any' },
+      { name: 'strongOnsets', type: 'any' },
+      { name: 'duration', type: 'number' },
+      { name: 'error', type: 'string' },
+    ],
+    params: {
+      mode: { type: 'string', default: 'ssh', description: 'ssh | http' },
+      peaksPerSecond: { type: 'int', default: 10, description: 'Waveform peaks resolution' },
+      sampleRate: { type: 'int', default: 22050, description: 'Audio sample rate for analysis' },
+      hopLength: { type: 'int', default: 512, description: 'Hop length for beat tracking' },
+      // 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' },
+      scriptPath: { type: 'string', default: '', description: 'Local path to beat-detection.py (auto-resolved)' },
+      // HTTP params
+      endpoint: { type: 'string', default: 'http://localhost:5009', description: 'Beat detection HTTP endpoint' },
+      timeout: { type: 'int', default: 180000, description: 'Max wait time (ms)' },
+    },
+  },
+
+  lifecycle: {
+    validate: (inputs) => {
+      if (!inputs.audioPath) return false;
+      return true;
+    },
+
+    cacheKey: (inputs, params) =>
+      `beat:${params.mode}:${inputs.audioPath}:${params.peaksPerSecond}:${params.sampleRate}`,
+
+    execute: async (inputs, params) => {
+      const { audioPath } = inputs;
+      const mode = params.mode || 'ssh';
+
+      if (mode === 'http') {
+        return executeHTTP(audioPath, params);
+      }
+      return executeSSH(audioPath, params);
+    },
+  },
+};
+
+/** @type {Object} Empty result template */
+const EMPTY = {
+  beats: null, tempo: 0, peaks: null, energy: null,
+  quietZones: null, strongOnsets: null, duration: 0, error: null,
+};
+
+/**
+ * SSH mode: upload audio → run librosa beat detection → parse JSON result
+ * @param {string} audioPath - Local path to audio file
+ * @param {Object} params - Node params
+ * @returns {Promise<Object>}
+ */
+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 sr = params.sampleRate || parseInt(process.env.BEAT_SAMPLE_RATE, 10) || 22050;
+  const hop = params.hopLength || parseInt(process.env.BEAT_HOP_LENGTH, 10) || 512;
+  const pps = params.peaksPerSecond || 10;
+  const remoteTmpDir = '/tmp/agi-graph-beat';
+
+  try {
+    // Verify local file exists
+    await fs.access(audioPath);
+
+    const filename = path.basename(audioPath);
+    const remoteAudio = `${remoteTmpDir}/${filename}`;
+
+    // Setup remote directory
+    execSync(`ssh ${host} "mkdir -p ${remoteTmpDir}"`, {
+      encoding: 'utf-8', stdio: 'pipe', timeout: 10000,
+    });
+
+    // Upload audio
+    execSync(`scp "${audioPath}" "${host}:${remoteAudio}"`, {
+      encoding: 'utf-8', stdio: 'pipe', timeout: 60000,
+    });
+
+    // Upload or locate beat detection script
+    let remoteScript = `${remoteTmpDir}/beat-detection.py`;
+    const localScript = params.scriptPath
+      || path.join(process.cwd(), 'utils/beat-detection.py');
+
+    try {
+      await fs.access(localScript);
+      execSync(`scp "${localScript}" "${host}:${remoteScript}"`, {
+        encoding: 'utf-8', stdio: 'pipe', timeout: 10000,
+      });
+    } catch {
+      // Script might already be on remote, try using module path
+      remoteScript = `${remotePath}/utils/beat-detection.py`;
+    }
+
+    try {
+      // Run beat detection
+      const pythonCmd = `${venv}/bin/python3`;
+      const cmd = `"${pythonCmd}" "${remoteScript}" "${remoteAudio}" --sr ${sr} --hop ${hop} --pps ${pps}`;
+      const fullCmd = `ssh ${host} '${cmd}'`;
+
+      const output = execSync(fullCmd, {
+        encoding: 'utf-8',
+        maxBuffer: 50 * 1024 * 1024,
+        timeout: params.timeout || 180000,
+      });
+
+      const result = JSON.parse(output);
+
+      return {
+        beats: result.beats,
+        tempo: result.tempo,
+        peaks: result.peaks,
+        energy: result.energy,
+        quietZones: result.quiet_zones,
+        strongOnsets: result.strong_onsets,
+        duration: result.duration,
+        error: null,
+      };
+    } finally {
+      // Cleanup remote audio
+      execSync(`ssh ${host} "rm -f ${remoteAudio}"`, {
+        encoding: 'utf-8', stdio: 'pipe', timeout: 5000,
+      }).toString();
+    }
+  } catch (err) {
+    return { ...EMPTY, error: err.message };
+  }
+}
+
+/**
+ * HTTP mode: POST audio to beat detection API
+ * @param {string} audioPath - Local path to audio file
+ * @param {Object} params - Node params
+ * @returns {Promise<Object>}
+ */
+async function executeHTTP(audioPath, params) {
+  const endpoint = params.endpoint || 'http://localhost:5009';
+
+  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('sample_rate', String(params.sampleRate || 22050));
+    formData.append('hop_length', String(params.hopLength || 512));
+    formData.append('peaks_per_second', String(params.peaksPerSecond || 10));
+
+    const response = await fetch(`${endpoint}/analyze`, {
+      method: 'POST',
+      body: formData,
+      signal: AbortSignal.timeout(params.timeout || 180000),
+    });
+
+    if (!response.ok) {
+      return { ...EMPTY, error: `Beat API error: ${response.status}` };
+    }
+
+    const result = await response.json();
+
+    return {
+      beats: result.beats,
+      tempo: result.tempo,
+      peaks: result.peaks,
+      energy: result.energy,
+      quietZones: result.quiet_zones,
+      strongOnsets: result.strong_onsets,
+      duration: result.duration,
+      error: null,
+    };
+  } catch (err) {
+    return { ...EMPTY, error: err.message };
+  }
+}

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

@@ -0,0 +1,238 @@
+/**
+ * ai/content-adapt — AI Content Adaptation
+ *
+ * Adapts content to target language levels using AI (OpenRouter).
+ * Supports news adaptation, trending topic adaptation, and generic
+ * content adaptation with vocabulary extraction and grammar notes.
+ *
+ * Ported from Mr-Computer/automations/argentine-spanish-bot/src/services/contentAdaptationService.js
+ *
+ * @module agi-graph/packs/ai/content-adapt
+ */
+
+/**
+ * Simple in-memory cache
+ * @type {Map<string, {data: any, timestamp: number}>}
+ */
+const cache = new Map();
+
+/**
+ * Simple hash for caching
+ * @param {string} str
+ * @returns {string}
+ */
+function hashStr(str) {
+  let hash = 0;
+  for (let i = 0; i < str.length; i++) {
+    hash = ((hash << 5) - hash) + str.charCodeAt(i);
+    hash |= 0;
+  }
+  return Math.abs(hash).toString(36);
+}
+
+/**
+ * Create adaptation prompt for AI
+ * @param {string} content
+ * @param {string} contentType
+ * @param {string} targetLevel
+ * @param {Object} options
+ * @returns {string}
+ */
+function createAdaptationPrompt(content, contentType, targetLevel, options) {
+  const typeLabels = {
+    news: 'a news article',
+    trending: 'a trending topic',
+    general: 'educational content',
+  };
+
+  let prompt = `You are a language adaptation specialist. Adapt the following ${typeLabels[contentType] || 'content'} to ${targetLevel} level Spanish (Rioplatense dialect).\n\n`;
+
+  prompt += `ORIGINAL CONTENT:\n${content}\n\n`;
+
+  prompt += `REQUIREMENTS:\n`;
+  prompt += `- Adapt vocabulary and grammar to ${targetLevel} level\n`;
+  prompt += `- Use Rioplatense Spanish (vos instead of tú, local vocabulary)\n`;
+  prompt += `- Keep the essential information\n`;
+  prompt += `- Maximum 350-550 characters for the adapted text\n`;
+
+  if (options.includeVocabulary !== false) {
+    prompt += `- Extract 10 key vocabulary items with translations (es→ru)\n`;
+  }
+  if (options.includeGrammarNotes !== false) {
+    prompt += `- Include 1-2 grammar notes relevant to the content\n`;
+  }
+  if (options.includeLesson !== false) {
+    prompt += `- Create a micro-lesson (A1 level) inspired by the content\n`;
+  }
+
+  prompt += `\nOUTPUT FORMAT: JSON object with fields: adaptedContent, vocabulary (array of {es, ru}), grammarNotes (array of {concept, explanation}), lesson (object with title_es, focus, examples)\n`;
+
+  return prompt;
+}
+
+/**
+ * Parse structured AI response
+ * @param {string} responseText
+ * @returns {Object}
+ */
+function parseAiResponse(responseText) {
+  // Try to extract JSON from response
+  const jsonMatch = responseText.match(/\{[\s\S]*\}/);
+  if (jsonMatch) {
+    try {
+      return JSON.parse(jsonMatch[0]);
+    } catch { /* fallback */ }
+  }
+  return { adaptedContent: responseText, vocabulary: [], grammarNotes: [] };
+}
+
+/**
+ * Calculate complexity score for content
+ * @param {string} content
+ * @returns {number}
+ */
+function calculateComplexity(content) {
+  const words = content.split(/\s+/);
+  const avgWordLength = words.reduce((sum, w) => sum + w.length, 0) / words.length;
+  const sentenceCount = content.split(/[.!?]+/).filter(Boolean).length;
+  const avgSentenceLength = words.length / sentenceCount;
+
+  // Simple score 0-1 based on word and sentence length
+  const score = Math.min(1, (avgWordLength / 10 + avgSentenceLength / 30) / 2);
+  return Math.round(score * 100) / 100;
+}
+
+// ─── Handler Definition ────────────────────────────────────────────────
+
+export default {
+  type: 'ai/content-adapt',
+  category: 'ai',
+  icon: 'auto_fix_high',
+
+  driver: {
+    description: 'AI-powered content adaptation to target language levels with vocabulary extraction',
+    inputs: [
+      { name: 'content', type: 'string' },
+    ],
+    outputs: [
+      { name: 'result', type: 'any' },
+      { name: 'error', type: 'string' },
+    ],
+    params: {
+      operation: { type: 'string', default: 'adapt', description: 'Operation: adapt | adapt-news | adapt-trending' },
+      apiKey: { type: 'string', default: null, description: 'OpenRouter API key (or OPENROUTER_API_KEY env)' },
+      model: { type: 'string', default: 'anthropic/claude-sonnet-4', description: 'AI model to use' },
+      targetLevel: { type: 'string', default: 'A1', description: 'Target language level (A1, A2, B1, B2)' },
+      // Content metadata
+      title: { type: 'string', default: null, description: 'Content title (for news/trending)' },
+      sourceUrl: { type: 'string', default: null, description: 'Source URL' },
+      // Options
+      includeVocabulary: { type: 'boolean', default: true, description: 'Include vocabulary extraction' },
+      includeGrammarNotes: { type: 'boolean', default: true, description: 'Include grammar notes' },
+      includeLesson: { type: 'boolean', default: true, description: 'Include micro-lesson' },
+      // Rate limiting
+      maxRetries: { type: 'int', default: 3, description: 'Maximum retry attempts' },
+    },
+  },
+
+  lifecycle: {
+    validate: (inputs, params) => {
+      if (typeof inputs.content !== 'string' || inputs.content.length === 0) return false;
+      const apiKey = params.apiKey || process.env.OPENROUTER_API_KEY;
+      if (!apiKey) return false;
+      return true;
+    },
+
+    cacheKey: (inputs, params) => {
+      return `content-adapt:${params.operation}:${params.targetLevel}:${hashStr(inputs.content.slice(0, 200))}`;
+    },
+
+    execute: async (inputs, params) => {
+      const { content } = inputs;
+      const { operation, model, targetLevel, maxRetries } = params;
+      const apiKey = params.apiKey || process.env.OPENROUTER_API_KEY;
+
+      try {
+        // Check cache
+        const cacheKey = `${operation}:${hashStr(content.slice(0, 200))}`;
+        const cached = cache.get(cacheKey);
+        if (cached && Date.now() - cached.timestamp < 3600000) {
+          return { result: { ...cached.data, cached: true } };
+        }
+
+        // Determine content type
+        const contentType = operation === 'adapt-news' ? 'news'
+          : operation === 'adapt-trending' ? 'trending'
+            : 'general';
+
+        const fullContent = params.title
+          ? `Title: ${params.title}\n\n${content}`
+          : content;
+
+        const prompt = createAdaptationPrompt(fullContent, contentType, targetLevel, {
+          includeVocabulary: params.includeVocabulary,
+          includeGrammarNotes: params.includeGrammarNotes,
+          includeLesson: params.includeLesson,
+        });
+
+        // Make API request with retry
+        let lastError;
+        for (let attempt = 0; attempt < maxRetries; attempt++) {
+          try {
+            const response = await fetch('https://openrouter.ai/api/v1/chat/completions', {
+              method: 'POST',
+              headers: {
+                'Content-Type': 'application/json',
+                'Authorization': `Bearer ${apiKey}`,
+              },
+              body: JSON.stringify({
+                model,
+                messages: [{ role: 'user', content: prompt }],
+                temperature: 0.7,
+              }),
+            });
+
+            if (!response.ok) {
+              lastError = `API error: HTTP ${response.status}`;
+              if (attempt < maxRetries - 1) {
+                await new Promise(r => setTimeout(r, 1000 * (attempt + 1)));
+                continue;
+              }
+              return { error: lastError };
+            }
+
+            const data = await response.json();
+            const aiResponse = data.choices?.[0]?.message?.content || '';
+
+            const parsed = parseAiResponse(aiResponse);
+            const complexity = calculateComplexity(content);
+
+            const result = {
+              original: content,
+              adapted: parsed,
+              contentType,
+              targetLevel,
+              complexity,
+              model,
+              sourceUrl: params.sourceUrl,
+            };
+
+            // Update cache
+            cache.set(cacheKey, { data: result, timestamp: Date.now() });
+
+            return { result };
+          } catch (err) {
+            lastError = err.message;
+            if (attempt < maxRetries - 1) {
+              await new Promise(r => setTimeout(r, 1000 * (attempt + 1)));
+            }
+          }
+        }
+
+        return { error: `content-adapt failed after ${maxRetries} attempts: ${lastError}` };
+      } catch (err) {
+        return { error: `content-adapt ${operation} failed: ${err.message}` };
+      }
+    },
+  },
+};