project-graph-mcp 2.3.2 → 2.4.0

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

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

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

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