project-graph-mcp 2.3.1 → 2.3.2

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

@@ -0,0 +1,193 @@
+/**
+ * data/prompt-loader — Dynamic Markdown template assembly
+ *
+ * Loads and processes MD prompt templates with variable substitution
+ * and recursive file includes. Supports {{VARIABLE}} placeholders and
+ * {{file.md}} file includes.
+ *
+ * Ported from Mr-Computer/automations/argentine-spanish-bot/src/utils/prompt-loader.js
+ *
+ * @module agi-graph/packs/data/prompt-loader
+ */
+
+import { readFile, readdir } from 'node:fs/promises';
+import path from 'node:path';
+
+/**
+ * Process template with variables and file includes
+ * @param {string} template - Template string
+ * @param {Object} context - Variables to substitute
+ * @param {string} baseDir - Base directory for relative includes
+ * @returns {Promise<string>}
+ */
+async function processTemplate(template, context, baseDir) {
+  let result = template;
+
+  // Process file includes: {{file.md}} or {{path/to/file.md}}
+  const fileIncludeRegex = /\{\{([a-zA-Z0-9_\-\/\.]+\.md)\}\}/g;
+  let match;
+
+  while ((match = fileIncludeRegex.exec(result)) !== null) {
+    const filePath = match[1];
+    const fullMatch = match[0];
+
+    try {
+      let includeContent = await readFile(path.join(baseDir, filePath), 'utf-8');
+      // Recursively process included content
+      includeContent = await processTemplate(includeContent, context, path.dirname(path.join(baseDir, filePath)));
+      result = result.replace(fullMatch, includeContent);
+    } catch {
+      // Leave placeholder as is
+    }
+  }
+
+  // Process variables: {{VARIABLE_NAME}}
+  const variableRegex = /\{\{([A-Z_][A-Z0-9_]*)\}\}/g;
+
+  result = result.replace(variableRegex, (fullMatch, varName) => {
+    if (Object.hasOwn(context, varName)) {
+      const value = context[varName];
+      if (typeof value === 'string') return value;
+      if (typeof value === 'number' || typeof value === 'boolean') return String(value);
+      if (Array.isArray(value)) return value.join('\n');
+      if (typeof value === 'object' && value !== null) return JSON.stringify(value, null, 2);
+      return String(value);
+    }
+    return fullMatch;
+  });
+
+  return result;
+}
+
+/**
+ * Validate prompt template — check for missing variables
+ * @param {string} template
+ * @param {Object} context
+ * @returns {Array<string>}
+ */
+function validatePromptTemplate(template, context) {
+  const variableRegex = /\{\{([A-Z_][A-Z0-9_]*)\}\}/g;
+  const missing = [];
+  let match;
+  while ((match = variableRegex.exec(template)) !== null) {
+    const varName = match[1];
+    if (!Object.hasOwn(context, varName)) missing.push(varName);
+  }
+  return [...new Set(missing)];
+}
+
+/**
+ * List available prompt templates in directory
+ * @param {string} dir
+ * @returns {Promise<Array<string>>}
+ */
+async function listPromptTemplates(dir) {
+  try {
+    const entries = await readdir(dir, { recursive: true });
+    return entries.filter(e => e.endsWith('.md'));
+  } catch {
+    return [];
+  }
+}
+
+// ─── Handler Definition ────────────────────────────────────────────────
+
+export default {
+  type: 'data/prompt-loader',
+  category: 'data',
+  icon: 'article',
+
+  driver: {
+    description: 'Dynamic Markdown template assembly with {{VARIABLE}} substitution and {{file.md}} includes',
+    inputs: [
+      { name: 'template', type: 'string' },
+    ],
+    outputs: [
+      { name: 'result', type: 'any' },
+      { name: 'error', type: 'string' },
+    ],
+    params: {
+      operation: { type: 'string', default: 'load', description: 'Operation: load | load-multi | validate | list' },
+      context: { type: 'any', default: {}, description: 'Variables map for template substitution' },
+      baseDir: { type: 'string', default: '.', description: 'Base directory for file includes' },
+      // load-multi
+      templates: { type: 'any', default: null, description: 'Map of {name: path} for load-multi' },
+      // load from file
+      filePath: { type: 'string', default: null, description: 'Path to template file (alternative to template input)' },
+    },
+  },
+
+  lifecycle: {
+    validate: (inputs, params) => {
+      const op = params.operation;
+      if (op === 'list') return typeof params.baseDir === 'string';
+      if (op === 'load-multi') return typeof params.templates === 'object' && params.templates !== null;
+      if (op === 'validate') return typeof inputs.template === 'string';
+      // load
+      return typeof inputs.template === 'string' || typeof params.filePath === 'string';
+    },
+
+    cacheKey: (inputs, params) => {
+      if (params.operation === 'list') return `prompt-list:${params.baseDir}`;
+      return null; // templates change with context
+    },
+
+    execute: async (inputs, params) => {
+      const { operation, context, baseDir } = params;
+
+      try {
+        switch (operation) {
+          case 'load': {
+            let template = inputs.template;
+            let resolvedBase = baseDir;
+
+            if (!template && params.filePath) {
+              const fullPath = path.isAbsolute(params.filePath)
+                ? params.filePath
+                : path.join(baseDir, params.filePath);
+              template = await readFile(fullPath, 'utf-8');
+              resolvedBase = path.dirname(fullPath);
+            }
+
+            const processed = await processTemplate(template, context, resolvedBase);
+            return { result: { content: processed, variablesUsed: Object.keys(context) } };
+          }
+
+          case 'load-multi': {
+            const entries = Object.entries(params.templates);
+            const results = {};
+            for (const [name, templatePath] of entries) {
+              const fullPath = path.isAbsolute(templatePath)
+                ? templatePath
+                : path.join(baseDir, templatePath);
+              const raw = await readFile(fullPath, 'utf-8');
+              results[name] = await processTemplate(raw, context, path.dirname(fullPath));
+            }
+            return { result: { templates: results, count: entries.length } };
+          }
+
+          case 'validate': {
+            const missing = validatePromptTemplate(inputs.template, context);
+            return {
+              result: {
+                valid: missing.length === 0,
+                missing,
+                totalVariables: (inputs.template.match(/\{\{([A-Z_][A-Z0-9_]*)\}\}/g) || []).length,
+              },
+            };
+          }
+
+          case 'list': {
+            const templates = await listPromptTemplates(baseDir);
+            return { result: { templates, count: templates.length, baseDir } };
+          }
+
+          default:
+            return { error: `Unknown operation: ${operation}` };
+        }
+      } catch (err) {
+        return { error: `prompt-loader ${operation} failed: ${err.message}` };
+      }
+    },
+  },
+};

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

@@ -0,0 +1,216 @@
+/**
+ * data/roles — Instruction & Role Manager
+ *
+ * Manages AI roles/instructions from Markdown files with YAML frontmatter.
+ * Supports listing, filtering by tags, combining roles into system prompts,
+ * and scanning directories for role files.
+ *
+ * Ported from Mr-Computer/modules/razrab-bot/src/services/roles-service.js
+ *
+ * @module agi-graph/packs/data/roles
+ */
+
+import { readFile, readdir, stat } from 'node:fs/promises';
+import path from 'node:path';
+
+/**
+ * Parse YAML frontmatter from markdown content
+ * @param {string} content
+ * @returns {{ frontmatter: Object, body: string }}
+ */
+function parseFrontmatter(content) {
+  const fmRegex = /^---\s*\n([\s\S]*?)\n---\s*\n([\s\S]*)$/;
+  const match = content.match(fmRegex);
+  if (!match) return { frontmatter: {}, body: content.trim() };
+
+  const fmText = match[1];
+  const body = match[2].trim();
+  const frontmatter = {};
+
+  for (const line of fmText.split('\n')) {
+    const colonIdx = line.indexOf(':');
+    if (colonIdx < 0) continue;
+    const key = line.slice(0, colonIdx).trim();
+    let value = line.slice(colonIdx + 1).trim();
+
+    // Parse arrays (simple YAML inline [a, b, c])
+    if (value.startsWith('[') && value.endsWith(']')) {
+      value = value.slice(1, -1).split(',').map(v => v.trim().replace(/^["']|["']$/g, ''));
+    }
+    frontmatter[key] = value;
+  }
+
+  return { frontmatter, body };
+}
+
+/**
+ * Scan directory for role markdown files
+ * @param {string} dirPath
+ * @param {string} prefix
+ * @returns {Promise<Map<string, Object>>}
+ */
+async function scanRolesDirectory(dirPath, prefix = '') {
+  const roles = new Map();
+  const tags = new Set();
+
+  try {
+    const entries = await readdir(dirPath, { withFileTypes: true });
+
+    for (const entry of entries) {
+      const fullPath = path.join(dirPath, entry.name);
+
+      if (entry.isDirectory()) {
+        const subRoles = await scanRolesDirectory(fullPath, prefix ? `${prefix}/${entry.name}` : entry.name);
+        for (const [id, role] of subRoles) {
+          roles.set(id, role);
+          if (Array.isArray(role.tags)) role.tags.forEach(t => tags.add(t));
+        }
+        continue;
+      }
+
+      if (!entry.name.endsWith('.md')) continue;
+
+      const content = await readFile(fullPath, 'utf-8');
+      const { frontmatter, body } = parseFrontmatter(content);
+
+      const roleId = prefix
+        ? `${prefix}/${entry.name.replace('.md', '')}`
+        : entry.name.replace('.md', '');
+
+      const role = {
+        id: roleId,
+        name: frontmatter.name || frontmatter.title || roleId,
+        tags: Array.isArray(frontmatter.tags) ? frontmatter.tags : [],
+        description: frontmatter.description || '',
+        category: frontmatter.category || (prefix || 'general'),
+        content: body,
+        path: fullPath,
+      };
+
+      roles.set(roleId, role);
+      role.tags.forEach(t => tags.add(t));
+    }
+  } catch {
+    // Directory not found or unreadable
+  }
+
+  return roles;
+}
+
+// ─── Handler Definition ────────────────────────────────────────────────
+
+export default {
+  type: 'data/roles',
+  category: 'data',
+  icon: 'person',
+
+  driver: {
+    description: 'Manage AI roles/instructions from Markdown files with YAML frontmatter',
+    inputs: [
+      { name: 'rolesDir', type: 'string' },
+    ],
+    outputs: [
+      { name: 'result', type: 'any' },
+      { name: 'error', type: 'string' },
+    ],
+    params: {
+      operation: { type: 'string', default: 'list', description: 'Operation: list | get | filter-tags | combine | scan' },
+      roleId: { type: 'string', default: null, description: 'Role ID for get operation' },
+      tags: { type: 'any', default: null, description: 'Array of tags for filter-tags' },
+      matchAll: { type: 'boolean', default: true, description: 'Require ALL tags (true) or ANY tag (false)' },
+      roleIds: { type: 'any', default: null, description: 'Array of role IDs for combine operation' },
+    },
+  },
+
+  lifecycle: {
+    validate: (inputs) => {
+      return typeof inputs.rolesDir === 'string' && inputs.rolesDir.length > 0;
+    },
+
+    cacheKey: (inputs, params) => {
+      return `roles:${params.operation}:${inputs.rolesDir}:${params.roleId || ''}:${JSON.stringify(params.tags || '')}`;
+    },
+
+    execute: async (inputs, params) => {
+      const { rolesDir } = inputs;
+      const { operation } = params;
+
+      try {
+        // Scan directory for all roles
+        const roles = await scanRolesDirectory(rolesDir);
+
+        switch (operation) {
+          case 'list':
+          case 'scan': {
+            const allTags = new Set();
+            const rolesList = [];
+            for (const [id, role] of roles) {
+              rolesList.push({
+                id: role.id,
+                name: role.name,
+                tags: role.tags,
+                description: role.description,
+                category: role.category,
+              });
+              role.tags.forEach(t => allTags.add(t));
+            }
+            return {
+              result: {
+                roles: rolesList,
+                count: rolesList.length,
+                tags: [...allTags].sort(),
+              },
+            };
+          }
+
+          case 'get': {
+            if (!params.roleId) return { error: 'roleId is required for get operation' };
+            const role = roles.get(params.roleId);
+            if (!role) return { error: `Role not found: ${params.roleId}` };
+            return { result: { role } };
+          }
+
+          case 'filter-tags': {
+            if (!Array.isArray(params.tags)) return { error: 'tags array is required' };
+            const filtered = [];
+            for (const [, role] of roles) {
+              const match = params.matchAll
+                ? params.tags.every(t => role.tags.includes(t))
+                : params.tags.some(t => role.tags.includes(t));
+              if (match) filtered.push(role);
+            }
+            return { result: { roles: filtered, count: filtered.length } };
+          }
+
+          case 'combine': {
+            if (!Array.isArray(params.roleIds)) return { error: 'roleIds array is required' };
+            const parts = [];
+            const resolved = [];
+            const missing = [];
+            for (const id of params.roleIds) {
+              const role = roles.get(id);
+              if (role) {
+                parts.push(`# ${role.name}\n\n${role.content}`);
+                resolved.push(id);
+              } else {
+                missing.push(id);
+              }
+            }
+            return {
+              result: {
+                systemPrompt: parts.join('\n\n---\n\n'),
+                resolved,
+                missing,
+              },
+            };
+          }
+
+          default:
+            return { error: `Unknown operation: ${operation}` };
+        }
+      } catch (err) {
+        return { error: `roles ${operation} failed: ${err.message}` };
+      }
+    },
+  },
+};

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

@@ -0,0 +1,244 @@
+/**
+ * data/rss-feed — RSS Feed Fetcher
+ *
+ * Fetches and parses RSS feeds with caching, retry logic, and rate limiting.
+ * Supports multi-source aggregation with category rotation and topic categorization.
+ *
+ * Ported from Mr-Computer/automations/argentine-spanish-bot/src/services/rss-feed.js
+ *
+ * @module symbiote-node/packs/data/rss-feed */
+
+/**
+ * Simple hash for dedup
+ * @param {string} str
+ * @returns {string}
+ */
+function simpleHash(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);
+}
+
+/**
+ * Extract image URL from RSS item
+ * @param {Object} item
+ * @returns {string|null}
+ */
+function extractImageUrl(item) {
+  if (item.enclosure?.url) return item.enclosure.url;
+  if (item['media:content']?.$.url) return item['media:content'].$.url;
+  const imgMatch = (item.content || item['content:encoded'] || '').match(/<img[^>]+src=["']([^"']+)/);
+  if (imgMatch) return imgMatch[1];
+  return null;
+}
+
+// Category definitions for topic classification
+const CATEGORIES = [
+  { id: 'politica', name: 'Política', keywords: ['presidente', 'gobierno', 'congreso', 'diputado', 'senador', 'ley', 'decreto', 'ministerio', 'elecciones', 'votación'] },
+  { id: 'economia', name: 'Economía', keywords: ['dólar', 'peso', 'inflación', 'bcra', 'mercado', 'bolsa', 'precio', 'sueldo', 'impuesto', 'deuda'] },
+  { id: 'deportes', name: 'Deportes', keywords: ['gol', 'partido', 'fútbol', 'selección', 'liga', 'mundial', 'copa', 'técnico', 'jugador', 'cancha'] },
+  { id: 'sociedad', name: 'Sociedad', keywords: ['vecinos', 'barrio', 'ciudad', 'protesta', 'educación', 'salud', 'hospital', 'seguridad', 'policía'] },
+  { id: 'tecnologia', name: 'Tecnología', keywords: ['app', 'inteligencia artificial', 'robot', 'celular', 'internet', 'red social', 'digital', 'hacker'] },
+  { id: 'cultura', name: 'Cultura', keywords: ['cine', 'teatro', 'música', 'festival', 'museo', 'libro', 'artista', 'exposición', 'concierto'] },
+  { id: 'internacional', name: 'Internacional', keywords: ['eeuu', 'estados unidos', 'europa', 'china', 'rusia', 'brasil', 'guerra', 'otan', 'onu'] },
+  { id: 'clima', name: 'Clima', keywords: ['temperatura', 'lluvia', 'viento', 'tormenta', 'calor', 'frío', 'pronóstico', 'ola de calor'] },
+];
+
+/**
+ * Categorize a topic based on title and content
+ * @param {string} title
+ * @param {string} content
+ * @returns {{ id: string, name: string }}
+ */
+function categorizeTopic(title, content) {
+  const combined = `${title} ${content}`.toLowerCase();
+  let bestCategory = { id: 'general', name: 'General' };
+  let bestScore = 0;
+
+  for (const cat of CATEGORIES) {
+    let score = 0;
+    for (const kw of cat.keywords) {
+      if (combined.includes(kw)) score++;
+    }
+    if (score > bestScore) {
+      bestScore = score;
+      bestCategory = { id: cat.id, name: cat.name };
+    }
+  }
+
+  return bestCategory;
+}
+
+/**
+ * Parse RSS XML manually (lightweight, no dependency)
+ * @param {string} xml
+ * @returns {Array<Object>}
+ */
+function parseRssXml(xml) {
+  const items = [];
+  const itemRegex = /<item>([\s\S]*?)<\/item>/gi;
+  let match;
+
+  while ((match = itemRegex.exec(xml)) !== null) {
+    const content = match[1];
+    const getTag = (tag) => {
+      const m = content.match(new RegExp(`<${tag}[^>]*><!\\[CDATA\\[([\\s\\S]*?)\\]\\]><\\/${tag}>|<${tag}[^>]*>([\\s\\S]*?)<\\/${tag}>`, 'i'));
+      return m ? (m[1] || m[2] || '').trim() : '';
+    };
+
+    items.push({
+      title: getTag('title'),
+      link: getTag('link'),
+      description: getTag('description'),
+      pubDate: getTag('pubDate'),
+      content: getTag('content:encoded') || getTag('description'),
+    });
+  }
+
+  return items;
+}
+
+// ─── Handler Definition ────────────────────────────────────────────────
+
+export default {
+  type: 'data/rss-feed',
+  category: 'data',
+  icon: 'rss_feed',
+
+  driver: {
+    description: 'Fetch and parse RSS feeds with caching, categorization, and multi-source support',
+    inputs: [
+      { name: 'url', type: 'string' },
+    ],
+    outputs: [
+      { name: 'result', type: 'any' },
+      { name: 'error', type: 'string' },
+    ],
+    params: {
+      operation: { type: 'string', default: 'fetch', description: 'Operation: fetch | fetch-multi | categorize' },
+      urls: { type: 'any', default: null, description: 'Array of URLs for fetch-multi' },
+      maxItems: { type: 'int', default: 20, description: 'Maximum items to return per feed' },
+      timeout: { type: 'int', default: 10000, description: 'Fetch timeout in ms' },
+      // categorize
+      items: { type: 'any', default: null, description: 'Array of {title, content} for categorize operation' },
+    },
+  },
+
+  lifecycle: {
+    validate: (inputs, params) => {
+      const op = params.operation;
+      if (op === 'categorize') return Array.isArray(params.items);
+      if (op === 'fetch-multi') return Array.isArray(params.urls) && params.urls.length > 0;
+      return typeof inputs.url === 'string' && inputs.url.startsWith('http');
+    },
+
+    cacheKey: (inputs, params) => {
+      if (params.operation === 'categorize') return null;
+      const url = params.operation === 'fetch-multi'
+        ? params.urls.join(',')
+        : inputs.url;
+      return `rss:${params.operation}:${simpleHash(url)}`;
+    },
+
+    execute: async (inputs, params) => {
+      const { operation, maxItems, timeout } = params;
+
+      try {
+        switch (operation) {
+          case 'fetch': {
+            const response = await fetch(inputs.url, {
+              signal: AbortSignal.timeout(timeout),
+              headers: { 'User-Agent': 'symbiote-node/rss-feed/1.0' },            });
+            if (!response.ok) return { error: `HTTP ${response.status}: ${response.statusText}` };
+
+            const xml = await response.text();
+            const rawItems = parseRssXml(xml);
+
+            const items = rawItems.slice(0, maxItems).map(item => ({
+              id: simpleHash(item.title + item.link),
+              title: item.title,
+              link: item.link,
+              description: item.description,
+              pubDate: item.pubDate,
+              image: extractImageUrl(item),
+              category: categorizeTopic(item.title, item.description),
+            }));
+
+            return { result: { items, count: items.length, source: inputs.url } };
+          }
+
+          case 'fetch-multi': {
+            const allItems = [];
+            const errors = [];
+
+            for (const url of params.urls) {
+              try {
+                const response = await fetch(url, {
+                  signal: AbortSignal.timeout(timeout),
+                  headers: { 'User-Agent': 'symbiote-node/rss-feed/1.0' },                });
+                if (!response.ok) {
+                  errors.push({ url, error: `HTTP ${response.status}` });
+                  continue;
+                }
+
+                const xml = await response.text();
+                const rawItems = parseRssXml(xml);
+
+                for (const item of rawItems.slice(0, maxItems)) {
+                  allItems.push({
+                    id: simpleHash(item.title + item.link),
+                    title: item.title,
+                    link: item.link,
+                    description: item.description,
+                    pubDate: item.pubDate,
+                    image: extractImageUrl(item),
+                    category: categorizeTopic(item.title, item.description),
+                    source: url,
+                  });
+                }
+              } catch (err) {
+                errors.push({ url, error: err.message });
+              }
+            }
+
+            // Deduplicate by ID
+            const seen = new Set();
+            const unique = allItems.filter(item => {
+              if (seen.has(item.id)) return false;
+              seen.add(item.id);
+              return true;
+            });
+
+            return { result: { items: unique, count: unique.length, sources: params.urls.length, errors } };
+          }
+
+          case 'categorize': {
+            const categorized = params.items.map(item => ({
+              ...item,
+              category: categorizeTopic(item.title || '', item.content || item.description || ''),
+            }));
+
+            // Group by category
+            const grouped = {};
+            for (const item of categorized) {
+              const key = item.category.id;
+              if (!grouped[key]) grouped[key] = { category: item.category, items: [] };
+              grouped[key].items.push(item);
+            }
+
+            return { result: { categorized, grouped, count: categorized.length } };
+          }
+
+          default:
+            return { error: `Unknown operation: ${operation}` };
+        }
+      } catch (err) {
+        return { error: `rss-feed ${operation} failed: ${err.message}` };
+      }
+    },
+  },
+};