sinapse-ai 1.6.1 → 1.8.0

package/.sinapse-ai/infrastructure/scripts/ide-sync/persona-renderer.js

@@ -0,0 +1,97 @@
+/**
+ * Persona Renderer — shared across IDE transformers (cursor, antigravity,
+ * github-copilot).
+ *
+ * PARIDADE-IDE-002 (audit 2026-06-11): the transformers used to emit only
+ * name/title/whenToUse + a few commands — ~8% of the agent. The agent's actual
+ * operating contract (role, identity, style, focus, core principles) was
+ * dropped, so the IDE stub couldn't reason like the agent. This renderer pulls
+ * that content from the parsed YAML and emits it as portable Markdown so every
+ * IDE keeps the persona that matters. Pure data → markdown; no side effects.
+ *
+ * @module ide-sync/persona-renderer
+ */
+
+'use strict';
+
+/**
+ * Render the core_principles array. Each item is either a string or a
+ * single-key object like { CRITICAL: '…' } (the agent YAML convention).
+ * @param {Array} principles
+ * @param {number} [limit=12] - Cap to keep IDE rules lean.
+ * @returns {string} Markdown bullet list (empty string when none).
+ */
+function renderCorePrinciples(principles, limit = 12) {
+  if (!Array.isArray(principles) || principles.length === 0) return '';
+  const lines = [];
+  for (const p of principles) {
+    if (lines.length >= limit) break;
+    if (typeof p === 'string') {
+      if (p.trim()) lines.push(`- ${p.trim()}`);
+    } else if (p && typeof p === 'object') {
+      for (const [k, v] of Object.entries(p)) {
+        lines.push(`- **${k}:** ${String(v).trim()}`);
+      }
+    }
+  }
+  return lines.join('\n');
+}
+
+/**
+ * Render the persona block (role/identity/style/focus) + core principles for an
+ * agent. Returns portable Markdown sections, or '' when the agent has no rich
+ * YAML (e.g. plain-header agents) — callers keep their existing minimal output.
+ *
+ * @param {object} agentData - Parsed agent data (from agent-parser).
+ * @param {object} [opts]
+ * @param {boolean} [opts.includeCommunication=false] - Also emit tone/vocabulary.
+ * @returns {string} Markdown (possibly empty).
+ */
+function renderPersona(agentData, opts = {}) {
+  const yaml = (agentData && agentData.yaml) || {};
+  const persona = yaml.persona || {};
+  const profile = (agentData && agentData.persona_profile) || yaml.persona_profile || {};
+
+  let md = '';
+
+  const hasPersona = persona.role || persona.identity || persona.style || persona.focus;
+  if (hasPersona) {
+    md += '## Persona\n\n';
+    if (persona.role) md += `**Role:** ${persona.role}\n\n`;
+    if (persona.identity) md += `**Identity:** ${persona.identity}\n\n`;
+    if (persona.style) md += `**Style:** ${persona.style}\n\n`;
+    if (persona.focus) md += `**Focus:** ${persona.focus}\n\n`;
+  }
+
+  const principles = renderCorePrinciples(yaml.core_principles);
+  if (principles) {
+    md += `## Core Principles\n\n${principles}\n\n`;
+  }
+
+  if (opts.includeCommunication && profile.communication) {
+    const c = profile.communication;
+    const bits = [];
+    if (c.tone) bits.push(`tone ${c.tone}`);
+    if (Array.isArray(c.vocabulary) && c.vocabulary.length) {
+      bits.push(`vocabulary: ${c.vocabulary.slice(0, 8).join(', ')}`);
+    }
+    if (bits.length) md += `## Voice\n\n${bits.join(' · ')}\n\n`;
+  }
+
+  return md;
+}
+
+/**
+ * Rough persona-retention estimate (chars of rendered persona vs raw file).
+ * Used by tests to assert the IDE stub keeps materially more than the old ~8%.
+ * @param {object} agentData
+ * @returns {number} ratio 0..1
+ */
+function estimateRetention(agentData) {
+  const raw = (agentData && agentData.raw) || '';
+  if (!raw) return 0;
+  const rendered = renderPersona(agentData, { includeCommunication: true });
+  return rendered.length / raw.length;
+}
+
+module.exports = { renderPersona, renderCorePrinciples, estimateRetention };

package/.sinapse-ai/infrastructure/scripts/ide-sync/transformers/antigravity.js

@@ -0,0 +1,121 @@
+/**
+ * Antigravity Transformer - Cursor-style format
+ * @story 5.1 - IDE Sync Expansion
+ *
+ * Format: Similar to Cursor, condensed rules format (.md, no frontmatter)
+ * Includes a full "All Commands" section in addition to Quick/Key sections.
+ * Target: .antigravity/rules/agents/*.md
+ */
+
+const { getVisibleCommands, normalizeCommands } = require('../agent-parser');
+const { renderPersona } = require('../persona-renderer');
+
+/**
+ * Transform agent data to Antigravity format.
+ * Produces a plain Markdown file (no YAML frontmatter) with three command
+ * sections: Quick Commands, Key Commands (exclusive), and All Commands.
+ *
+ * @param {object} agentData - Parsed agent data from agent-parser
+ * @param {object|null} agentData.agent - Parsed agent YAML block
+ * @param {object|null} agentData.persona_profile - Persona profile block
+ * @param {string} agentData.id - Agent ID (basename without .md)
+ * @param {string} agentData.filename - Source filename (e.g. sinapse-orqx.md)
+ * @param {Array}  agentData.commands - Raw commands array
+ * @param {object} agentData.sections - Extracted markdown sections
+ * @returns {string} Transformed content ready to write to disk
+ */
+function transform(agentData) {
+  const agent = agentData.agent || {};
+  const persona = agentData.persona_profile || {};
+
+  const icon = agent.icon || '🤖';
+  const name = agent.name || agentData.id;
+  const title = agent.title || 'SINAPSE Agent';
+  const whenToUse = agent.whenToUse || 'Use this agent for specific tasks';
+  const archetype = persona.archetype || '';
+
+  // Normalize commands to a consistent {name, description, visibility} shape
+  const allCommands = normalizeCommands(agentData.commands || []);
+  const quickCommands = getVisibleCommands(allCommands, 'quick');
+  const keyCommands = getVisibleCommands(allCommands, 'key');
+
+  // Build header
+  let content = `# ${name} (@${agentData.id})
+
+${icon} **${title}**${archetype ? ` | ${archetype}` : ''}
+
+> ${whenToUse}
+
+`;
+
+  // PARIDADE-IDE-002: include the persona contract, not just the label.
+  content += renderPersona(agentData, { includeCommunication: true });
+
+  // Quick Commands section
+  if (quickCommands.length > 0) {
+    content += `## Quick Commands
+
+`;
+    for (const cmd of quickCommands) {
+      content += `- \`*${cmd.name}\` - ${cmd.description || 'No description'}\n`;
+    }
+    content += '\n';
+  }
+
+  // Key Commands section — only commands NOT already in Quick
+  const keyOnlyCommands = keyCommands.filter(
+    (k) => !quickCommands.some((q) => q.name === k.name)
+  );
+  if (keyOnlyCommands.length > 0) {
+    content += `## Key Commands
+
+`;
+    for (const cmd of keyOnlyCommands) {
+      content += `- \`*${cmd.name}\` - ${cmd.description || 'No description'}\n`;
+    }
+    content += '\n';
+  }
+
+  // All Commands section — shown when total exceeds what quick+key already covers
+  if (allCommands.length > quickCommands.length + keyOnlyCommands.length) {
+    content += `## All Commands
+
+`;
+    for (const cmd of allCommands) {
+      content += `- \`*${cmd.name}\` - ${cmd.description || 'No description'}\n`;
+    }
+    content += '\n';
+  }
+
+  // Collaboration section (optional)
+  if (agentData.sections && agentData.sections.collaboration) {
+    content += `## Collaboration
+
+${agentData.sections.collaboration}
+
+`;
+  }
+
+  content += `---
+*SINAPSE Agent - Synced from .sinapse-ai/development/agents/${agentData.filename}*
+`;
+
+  return content;
+}
+
+/**
+ * Get the target filename for this agent.
+ * Antigravity uses the same filename as the source agent file.
+ *
+ * @param {object} agentData - Parsed agent data
+ * @returns {string} Target filename (e.g. sinapse-orqx.md)
+ */
+function getFilename(agentData) {
+  return agentData.filename;
+}
+
+module.exports = {
+  transform,
+  getFilename,
+  format: 'cursor-style',
+};

package/.sinapse-ai/infrastructure/scripts/ide-sync/transformers/cursor.js

@@ -0,0 +1,119 @@
+/**
+ * Cursor Transformer - Condensed rules format
+ * @story 5.1 - IDE Sync Expansion
+ *
+ * Format: Cursor MDC rule with frontmatter, icon, title, quick commands
+ * Target: .cursor/rules/agents/*.mdc
+ */
+
+const { getVisibleCommands, normalizeCommands } = require('../agent-parser');
+const { renderPersona } = require('../persona-renderer');
+
+function escapeFrontmatterString(value) {
+  return String(value || '')
+    .replace(/\r?\n/g, ' ')
+    .replace(/'/g, "''")
+    .trim();
+}
+
+function toMdcFilename(filename, fallbackId = 'agent') {
+  const baseName = String(filename || `${fallbackId}.md`).replace(/\.md$/i, '');
+  return `${baseName}.mdc`;
+}
+
+/**
+ * Transform agent data to Cursor format
+ * @param {object} agentData - Parsed agent data from agent-parser
+ * @returns {string} - Transformed content
+ */
+function transform(agentData) {
+  const agent = agentData.agent || {};
+  const persona = agentData.persona_profile || {};
+
+  const icon = agent.icon || '🤖';
+  const name = agent.name || agentData.id;
+  const title = agent.title || 'SINAPSE Agent';
+  const whenToUse = agent.whenToUse || 'Use this agent for specific tasks';
+  const archetype = persona.archetype || '';
+  const description = escapeFrontmatterString(`SINAPSE agent @${agentData.id} - ${title}`);
+
+  // Get quick visibility commands (normalized to consistent format)
+  const allCommands = normalizeCommands(agentData.commands || []);
+  const quickCommands = getVisibleCommands(allCommands, 'quick');
+  const keyCommands = getVisibleCommands(allCommands, 'key');
+
+  // Build content
+  let content = `---
+description: '${description}'
+alwaysApply: false
+---
+
+# ${name} (@${agentData.id})
+
+${icon} **${title}**${archetype ? ` | ${archetype}` : ''}
+
+> ${whenToUse}
+
+`;
+
+  // PARIDADE-IDE-002: emit the persona contract (role/identity/style/focus +
+  // core principles) so the IDE stub reasons like the agent, not just a label.
+  content += renderPersona(agentData, { includeCommunication: true });
+
+  // Add quick commands section
+  if (quickCommands.length > 0) {
+    content += `## Quick Commands
+
+`;
+    for (const cmd of quickCommands) {
+      content += `- \`*${cmd.name}\` - ${cmd.description || 'No description'}\n`;
+    }
+    content += '\n';
+  }
+
+  // Add key commands if different from quick
+  const keyOnlyCommands = keyCommands.filter(
+    k => !quickCommands.some(q => q.name === k.name)
+  );
+  if (keyOnlyCommands.length > 0) {
+    content += `## Key Commands
+
+`;
+    for (const cmd of keyOnlyCommands) {
+      content += `- \`*${cmd.name}\` - ${cmd.description || 'No description'}\n`;
+    }
+    content += '\n';
+  }
+
+  // Add collaboration section if available
+  if (agentData.sections && agentData.sections.collaboration) {
+    content += `## Collaboration
+
+${agentData.sections.collaboration}
+
+`;
+  }
+
+  content += `---
+*SINAPSE Agent - Synced from .sinapse-ai/development/agents/${agentData.filename}*
+`;
+
+  return content;
+}
+
+/**
+ * Get the target filename for this agent
+ * @param {object} agentData - Parsed agent data
+ * @returns {string} - Target filename (.mdc extension)
+ */
+function getFilename(agentData) {
+  return toMdcFilename(agentData.filename, agentData.id);
+}
+
+module.exports = {
+  transform,
+  getFilename,
+  toMdcFilename,
+  escapeFrontmatterString,
+  format: 'condensed-rules',
+};

package/.sinapse-ai/infrastructure/scripts/ide-sync/transformers/github-copilot.js

@@ -0,0 +1,191 @@
+/**
+ * GitHub Copilot Transformer - YAML frontmatter + condensed markdown
+ * @story 5.1 - IDE Sync Expansion
+ *
+ * Format: .agent.md files with YAML frontmatter (--- delimiters)
+ * Target: .github/agents/*.agent.md
+ *
+ * GitHub Copilot custom agents require:
+ * - YAML frontmatter with `description` (required), `name`, `tools`
+ * - Markdown body under 30,000 characters
+ * - File extension: .agent.md
+ *
+ * @see https://docs.github.com/en/copilot/reference/custom-agents-configuration
+ */
+
+const { normalizeCommands, getVisibleCommands } = require('../agent-parser');
+
+/**
+ * Transform agent data to GitHub Copilot custom agent format
+ * @param {object} agentData - Parsed agent data from agent-parser
+ * @returns {string} - Transformed content with YAML frontmatter
+ */
+function transform(agentData) {
+  const agent = agentData.agent || {};
+  const persona = agentData.persona_profile || {};
+  const yamlData = agentData.yaml || {};
+  const personaBlock = yamlData.persona || {};
+
+  const id = agent.id || agentData.id;
+  const name = agent.name || id;
+  const title = agent.title || 'SINAPSE Agent';
+  const icon = agent.icon || '';
+  const description = escapeYamlString(agent.whenToUse || `${title} agent for development tasks`);
+
+  // Build YAML frontmatter
+  const frontmatter = [
+    '---',
+    `name: ${id}`,
+    `description: '${description}'`,
+    `tools: ['read', 'edit', 'search', 'execute']`,
+    '---',
+  ].join('\n');
+
+  // Build markdown body
+  const body = buildMarkdownBody({
+    id,
+    name,
+    title,
+    icon,
+    personaBlock,
+    persona,
+    commands: agentData.commands || [],
+    sections: agentData.sections || {},
+    corePrinciples: yamlData.core_principles,
+    filename: agentData.filename,
+  });
+
+  const content = `${frontmatter}\n\n${body}`;
+
+  // Enforce 30K character limit
+  if (content.length > 30000) {
+    return truncateContent(content, 30000);
+  }
+
+  return content;
+}
+
+/**
+ * Build the markdown body for the Copilot agent prompt
+ * @param {object} params - Agent parameters
+ * @returns {string} - Markdown body
+ */
+function buildMarkdownBody(params) {
+  const { id, name, title, icon, personaBlock, persona, commands, sections, filename } = params;
+
+  const parts = [];
+
+  // Header
+  const headerIcon = icon ? `${icon} ` : '';
+  parts.push(`# ${headerIcon}${name} Agent (@${id})\n`);
+
+  // Role description
+  if (personaBlock.role) {
+    parts.push(`You are an expert ${personaBlock.role}.\n`);
+  } else {
+    parts.push(`You are an expert ${title}.\n`);
+  }
+
+  // Identity + Focus (PARIDADE-IDE-002: keep the full persona contract)
+  if (personaBlock.identity) {
+    parts.push(`**Identity:** ${personaBlock.identity}\n`);
+  }
+  if (personaBlock.focus) {
+    parts.push(`**Focus:** ${personaBlock.focus}\n`);
+  }
+
+  // Style
+  if (personaBlock.style) {
+    parts.push(`## Style\n\n${personaBlock.style}\n`);
+  }
+
+  // Core principles (may be in persona block or at root level of YAML)
+  const corePrinciples = personaBlock.core_principles || params.corePrinciples;
+  if (corePrinciples && Array.isArray(corePrinciples)) {
+    parts.push('## Core Principles\n');
+    for (const principle of corePrinciples) {
+      // Handle both string and object formats (YAML may parse "KEY: value" as {KEY: value})
+      if (typeof principle === 'string') {
+        parts.push(`- ${principle}`);
+      } else if (typeof principle === 'object' && principle !== null) {
+        const entries = Object.entries(principle);
+        for (const [key, value] of entries) {
+          parts.push(`- ${key}: ${value}`);
+        }
+      }
+    }
+    parts.push('');
+  }
+
+  // Commands reference
+  const allCommands = normalizeCommands(commands);
+  const keyCommands = getVisibleCommands(allCommands, 'key');
+  const quickCommands = getVisibleCommands(allCommands, 'quick');
+  const displayCommands = keyCommands.length > 0 ? keyCommands : quickCommands.slice(0, 10);
+
+  if (displayCommands.length > 0) {
+    parts.push('## Commands\n');
+    parts.push('Use `*` prefix for commands:\n');
+    for (const cmd of displayCommands) {
+      parts.push(`- \`*${cmd.name}\` - ${cmd.description || 'No description'}`);
+    }
+    parts.push('');
+  }
+
+  // Collaboration section (condensed)
+  if (sections.collaboration) {
+    parts.push(`## Collaboration\n\n${sections.collaboration}\n`);
+  }
+
+  // Sync footer
+  parts.push('---');
+  parts.push(`*SINAPSE Agent - Synced from .sinapse-ai/development/agents/${filename}*`);
+  parts.push('');
+
+  return parts.join('\n');
+}
+
+/**
+ * Escape a string for use as a YAML single-quoted value
+ * Single quotes inside the string must be doubled
+ * @param {string} str - Input string
+ * @returns {string} - Escaped string
+ */
+function escapeYamlString(str) {
+  if (!str) return '';
+  // In YAML single-quoted strings, single quotes are escaped by doubling them
+  return str.replace(/'/g, "''");
+}
+
+/**
+ * Truncate content to fit within character limit while keeping structure valid
+ * @param {string} content - Full content
+ * @param {number} maxChars - Maximum characters
+ * @returns {string} - Truncated content
+ */
+function truncateContent(content, maxChars) {
+  // Find the last complete section before the limit
+  const truncated = content.substring(0, maxChars - 100);
+  const lastNewline = truncated.lastIndexOf('\n\n');
+
+  if (lastNewline > 0) {
+    return truncated.substring(0, lastNewline) + '\n\n---\n*Content truncated to fit 30K limit*\n';
+  }
+  return truncated + '\n\n---\n*Content truncated to fit 30K limit*\n';
+}
+
+/**
+ * Get the target filename for this agent (with .agent.md extension)
+ * @param {object} agentData - Parsed agent data
+ * @returns {string} - Target filename (e.g., "developer.agent.md")
+ */
+function getFilename(agentData) {
+  const id = (agentData.agent && agentData.agent.id) || agentData.id;
+  return `${id}.agent.md`;
+}
+
+module.exports = {
+  transform,
+  getFilename,
+  format: 'github-copilot',
+};