aios-core 4.2.3 → 4.2.5

package/.aios-core/infrastructure/scripts/ide-sync/gemini-commands.js

@@ -0,0 +1,205 @@
+'use strict';
+
+const fs = require('fs-extra');
+const path = require('path');
+
+const FALLBACK_DESCRIPTION = 'Agente especializado AIOS';
+const MAX_DESCRIPTION_CONTEXT = 120;
+
+const MENU_ORDER = [
+  'aios-master',
+  'analyst',
+  'architect',
+  'data-engineer',
+  'dev',
+  'devops',
+  'pm',
+  'po',
+  'qa',
+  'sm',
+  'squad-creator',
+  'ux-design-expert',
+];
+
+function commandSlugForAgent(agentId) {
+  if (agentId.startsWith('aios-')) {
+    return agentId.replace(/^aios-/, '');
+  }
+  return agentId;
+}
+
+function menuCommandName(agentId) {
+  return `/aios-${commandSlugForAgent(agentId)}`;
+}
+
+function normalizeText(text) {
+  if (!text || typeof text !== 'string') return '';
+  return text.replace(/\s+/g, ' ').trim();
+}
+
+function truncateText(text, maxLen = MAX_DESCRIPTION_CONTEXT) {
+  if (!text || text.length <= maxLen) return text;
+  return `${text.slice(0, maxLen - 1).trimEnd()}…`;
+}
+
+function summarizeWhenToUse(whenToUse) {
+  const normalized = normalizeText(whenToUse);
+  if (!normalized) return '';
+
+  // Drop redirect/negative guidance sections that are useful for routing, not for menu labels.
+  const withoutNegativeSection = normalized.split(/\b(?:NOT\s+for|NÃO\s+para)\b/i)[0].trim();
+  const primary = withoutNegativeSection || normalized;
+
+  // Keep only the first sentence/chunk for concise autocomplete labels.
+  const firstChunk = primary.split(/[.;!?](?:\s|$)/)[0].trim();
+  return truncateText(firstChunk || primary);
+}
+
+function escapeTomlString(text) {
+  return String(text || '').replace(/\\/g, '\\\\').replace(/"/g, '\\"');
+}
+
+function buildAgentDescription(agent) {
+  const agentData = agent.agent || {};
+  const title = normalizeText(agentData.title);
+  const whenToUseSummary = summarizeWhenToUse(agentData.whenToUse);
+
+  if (title && whenToUseSummary) {
+    return `${title} (${whenToUseSummary})`;
+  }
+  if (title) {
+    return title;
+  }
+  if (whenToUseSummary) {
+    return whenToUseSummary;
+  }
+  return `Ativar agente AIOS ${agent.id}`;
+}
+
+function buildAgentCommandPrompt(agentId) {
+  return [
+    `Ative o agente ${agentId}:`,
+    `1. Leia a definição completa em .gemini/rules/AIOS/agents/${agentId}.md`,
+    '2. Siga as activation-instructions do bloco YAML',
+    `3. Renderize o greeting via: node .aios-core/development/scripts/generate-greeting.js ${agentId}`,
+    '   Se shell nao disponivel, exiba o greeting de persona_profile.communication.greeting_levels.named',
+    '4. Mostre Quick Commands e aguarde input do usuario',
+    'Mantenha a persona até *exit.',
+  ].join('\n');
+}
+
+function buildAgentCommandFile(agentId, description = FALLBACK_DESCRIPTION) {
+  const slug = commandSlugForAgent(agentId);
+
+  const prompt = buildAgentCommandPrompt(agentId);
+  const content = [
+    `description = "${escapeTomlString(description)}"`,
+    'prompt = """',
+    prompt,
+    '"""',
+    '',
+  ].join('\n');
+
+  return {
+    filename: `aios-${slug}.toml`,
+    content,
+    agentId,
+    description,
+  };
+}
+
+function buildMenuPrompt(commandFiles) {
+  const lines = [
+    'Você está no launcher AIOS para Gemini.',
+    '',
+    'Mostre a lista de agentes abaixo em formato numerado, explicando em 1 linha quando usar cada um:',
+  ];
+
+  let index = 1;
+  for (const commandFile of commandFiles) {
+    lines.push(`${index}. ${menuCommandName(commandFile.agentId)} - ${commandFile.description}`);
+    index += 1;
+  }
+
+  lines.push('');
+  lines.push('No final, peça para o usuário escolher um número ou digitar o comando direto.');
+  return lines.join('\n');
+}
+
+function buildMenuCommandFile(commandFiles) {
+  const content = [
+    'description = "Menu rápido AIOS (lista agentes e orienta qual ativar)"',
+    'prompt = """',
+    buildMenuPrompt(commandFiles),
+    '"""',
+    '',
+  ].join('\n');
+
+  return {
+    filename: 'aios-menu.toml',
+    content,
+  };
+}
+
+function resolveAgentOrder(agentIds) {
+  const unique = [...new Set(agentIds)];
+  const known = MENU_ORDER.filter((id) => unique.includes(id));
+  const extra = unique.filter((id) => !MENU_ORDER.includes(id)).sort();
+  return [...known, ...extra];
+}
+
+function buildGeminiCommandFiles(agents) {
+  const validAgents = agents
+    .filter((agent) => !agent.error)
+    .map((agent) => ({
+      id: agent.id,
+      description: buildAgentDescription(agent),
+    }));
+
+  const ordered = resolveAgentOrder(validAgents.map((agent) => agent.id));
+  const byId = new Map(validAgents.map((agent) => [agent.id, agent]));
+  const files = ordered.map((id) => {
+    const meta = byId.get(id);
+    const description = meta?.description || FALLBACK_DESCRIPTION;
+    return buildAgentCommandFile(id, description);
+  });
+  files.unshift(buildMenuCommandFile(files));
+  return files;
+}
+
+function syncGeminiCommands(agents, projectRoot, options = {}) {
+  const commandsDir = path.join(projectRoot, '.gemini', 'commands');
+  const files = buildGeminiCommandFiles(agents);
+  const written = [];
+
+  if (!options.dryRun) {
+    fs.ensureDirSync(commandsDir);
+  }
+
+  for (const file of files) {
+    const targetPath = path.join(commandsDir, file.filename);
+    if (!options.dryRun) {
+      fs.writeFileSync(targetPath, file.content, 'utf8');
+    }
+    written.push({
+      filename: path.join('commands', file.filename),
+      path: targetPath,
+      content: file.content,
+    });
+  }
+
+  return { commandsDir, files: written };
+}
+
+module.exports = {
+  FALLBACK_DESCRIPTION,
+  MENU_ORDER,
+  commandSlugForAgent,
+  menuCommandName,
+  buildAgentDescription,
+  summarizeWhenToUse,
+  truncateText,
+  escapeTomlString,
+  buildGeminiCommandFiles,
+  syncGeminiCommands,
+};

package/.aios-core/infrastructure/scripts/ide-sync/index.js

@@ -24,11 +24,11 @@ const yaml = require('js-yaml');
 const { parseAllAgents } = require('./agent-parser');
 const { generateAllRedirects, writeRedirects } = require('./redirect-generator');
 const { validateAllIdes, formatValidationReport } = require('./validator');
+const { syncGeminiCommands, buildGeminiCommandFiles } = require('./gemini-commands');
 
 // Transformers
 const claudeCodeTransformer = require('./transformers/claude-code');
 const cursorTransformer = require('./transformers/cursor');
-const windsurfTransformer = require('./transformers/windsurf');
 const antigravityTransformer = require('./transformers/antigravity');
 
 // ANSI colors for output
@@ -66,16 +66,21 @@ function loadConfig(projectRoot) {
         path: '.codex/agents',
         format: 'full-markdown-yaml',
       },
+      gemini: {
+        enabled: true,
+        path: '.gemini/rules/AIOS/agents',
+        format: 'full-markdown-yaml',
+      },
+      'github-copilot': {
+        enabled: true,
+        path: '.github/agents',
+        format: 'full-markdown-yaml',
+      },
       cursor: {
         enabled: true,
         path: '.cursor/rules/agents',
         format: 'condensed-rules',
       },
-      windsurf: {
-        enabled: false, // Disabled - consolidating to core IDEs (v3.10.0)
-        path: '.windsurf/rules/agents',
-        format: 'xml-tagged-markdown',
-      },
       antigravity: {
         enabled: true,
         path: '.antigravity/rules/agents',
@@ -120,7 +125,6 @@ function getTransformer(format) {
   const transformers = {
     'full-markdown-yaml': claudeCodeTransformer,
     'condensed-rules': cursorTransformer,
-    'xml-tagged-markdown': windsurfTransformer,
     'cursor-style': antigravityTransformer,
   };
 
@@ -258,6 +262,15 @@ async function commandSync(options) {
     }
 
     const result = syncIde(agents, ideConfig, ideName, projectRoot, options);
+
+    // Gemini CLI: also sync slash launcher command files (.gemini/commands/*.toml)
+    if (ideName === 'gemini') {
+      const geminiCommands = syncGeminiCommands(agents, projectRoot, options);
+      result.commandFiles = geminiCommands.files;
+    } else {
+      result.commandFiles = [];
+    }
+
     results.push(result);
 
     // Generate redirects for this IDE
@@ -269,6 +282,7 @@ async function commandSync(options) {
     }
 
     const agentCount = result.files.length;
+    const commandCount = (result.commandFiles || []).length;
     const redirectCount = redirectResult.written.length;
     const errorCount = result.errors.length;
 
@@ -279,7 +293,7 @@ async function commandSync(options) {
       }
 
       console.log(
-        `   ${status} ${agentCount} agents, ${redirectCount} redirects${errorCount > 0 ? `, ${errorCount} errors` : ''}`
+        `   ${status} ${agentCount} agents${commandCount > 0 ? `, ${commandCount} commands` : ''}, ${redirectCount} redirects${errorCount > 0 ? `, ${errorCount} errors` : ''}`
       );
 
       if (options.verbose && result.errors.length > 0) {
@@ -291,7 +305,7 @@ async function commandSync(options) {
   }
 
   // Summary
-  const totalFiles = results.reduce((sum, r) => sum + r.files.length, 0);
+  const totalFiles = results.reduce((sum, r) => sum + r.files.length + (r.commandFiles || []).length, 0);
   const totalRedirects =
     Object.keys(config.redirects).length * targetIdes.filter(([, c]) => c.enabled).length;
   const totalErrors = results.reduce((sum, r) => sum + r.errors.length, 0);
@@ -337,9 +351,18 @@ async function commandValidate(options) {
 
   // Build expected files for each IDE
   const ideConfigs = {};
+  let targetIdes = Object.entries(config.targets).filter(([, ideConfig]) => ideConfig.enabled);
 
-  for (const [ideName, ideConfig] of Object.entries(config.targets)) {
-    if (!ideConfig.enabled) continue;
+  // Filter IDEs if --ide flag specified
+  if (options.ide) {
+    targetIdes = targetIdes.filter(([name]) => name === options.ide);
+    if (targetIdes.length === 0) {
+      console.error(`${colors.red}Error: IDE '${options.ide}' not found in config${colors.reset}`);
+      process.exit(1);
+    }
+  }
+
+  for (const [ideName, ideConfig] of targetIdes) {
 
     const transformer = getTransformer(ideConfig.format);
     const expectedFiles = [];
@@ -374,6 +397,18 @@ async function commandValidate(options) {
       expectedFiles,
       targetDir: path.join(projectRoot, ideConfig.path),
     };
+
+    // Gemini CLI command launcher files are synced under .gemini/commands/*.toml
+    if (ideName === 'gemini') {
+      const commandFiles = buildGeminiCommandFiles(agents).map((entry) => ({
+        filename: entry.filename,
+        content: entry.content,
+      }));
+      ideConfigs['gemini-commands'] = {
+        expectedFiles: commandFiles,
+        targetDir: path.join(projectRoot, '.gemini', 'commands'),
+      };
+    }
   }
 
   // Validate
@@ -450,7 +485,9 @@ ${colors.bright}Options:${colors.reset}
 ${colors.bright}Examples:${colors.reset}
   node ide-sync/index.js sync
   node ide-sync/index.js sync --ide codex
+  node ide-sync/index.js sync --ide gemini
   node ide-sync/index.js sync --ide cursor
+  node ide-sync/index.js validate --ide gemini --strict
   node ide-sync/index.js validate --strict
   node ide-sync/index.js sync --dry-run --verbose
 `);

package/.aios-core/infrastructure/scripts/ide-sync/redirect-generator.js

@@ -55,7 +55,7 @@ ${baseContent.instruction}
 `;
 
     case 'xml-tagged-markdown':
-      // Windsurf format
+      // Generic markdown format
       return `${baseContent.header}
 
 <redirect>

package/.aios-core/infrastructure/scripts/test-utilities.js

@@ -27,7 +27,7 @@ async function countIntegrationReferences(utilityName) {
   const searchDirs = [
     '.aios-core/agents',
     '.aios-core/tasks',
-    'expansion-packs',
+    'squads',
   ];
 
   let totalCount = 0;

package/.aios-core/infrastructure/scripts/tool-resolver.js

@@ -48,7 +48,7 @@ class ToolResolver {
     // 2. Build search paths (squad → core priority)
     const searchPaths = [];
     if (context.expansionPack) {
-      searchPaths.push(`expansion-packs/${context.expansionPack}/tools`);
+      searchPaths.push(`squads/${context.expansionPack}/tools`);
     }
     searchPaths.push(...this.basePaths);
 
@@ -304,7 +304,7 @@ class ToolResolver {
   async toolExists(toolName, context = {}) {
     const searchPaths = [];
     if (context.expansionPack) {
-      searchPaths.push(`expansion-packs/${context.expansionPack}/tools`);
+      searchPaths.push(`squads/${context.expansionPack}/tools`);
     }
     searchPaths.push(...this.basePaths);
 

package/.aios-core/infrastructure/scripts/validate-claude-integration.js

@@ -0,0 +1,101 @@
+#!/usr/bin/env node
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+
+function parseArgs(argv = process.argv.slice(2)) {
+  const args = new Set(argv);
+  return {
+    quiet: args.has('--quiet') || args.has('-q'),
+    json: args.has('--json'),
+  };
+}
+
+function countMarkdownFiles(dirPath) {
+  if (!fs.existsSync(dirPath)) return 0;
+  return fs.readdirSync(dirPath).filter((f) => f.endsWith('.md')).length;
+}
+
+function validateClaudeIntegration(options = {}) {
+  const projectRoot = options.projectRoot || process.cwd();
+  const rulesFile = options.rulesFile || path.join(projectRoot, '.claude', 'CLAUDE.md');
+  const agentsDir = options.agentsDir || path.join(projectRoot, '.claude', 'commands', 'AIOS', 'agents');
+  const hooksDir = options.hooksDir || path.join(projectRoot, '.claude', 'hooks');
+  const sourceAgentsDir =
+    options.sourceAgentsDir || path.join(projectRoot, '.aios-core', 'development', 'agents');
+
+  const errors = [];
+  const warnings = [];
+
+  if (!fs.existsSync(agentsDir)) {
+    errors.push(`Missing Claude agents dir: ${path.relative(projectRoot, agentsDir)}`);
+  }
+  if (!fs.existsSync(rulesFile)) {
+    warnings.push(`Claude rules file not found yet: ${path.relative(projectRoot, rulesFile)}`);
+  }
+  if (!fs.existsSync(hooksDir)) {
+    warnings.push(`Claude hooks dir not found yet: ${path.relative(projectRoot, hooksDir)}`);
+  }
+
+  const sourceCount = countMarkdownFiles(sourceAgentsDir);
+  const claudeCount = countMarkdownFiles(agentsDir);
+  if (sourceCount > 0 && claudeCount !== sourceCount) {
+    warnings.push(`Claude agent count differs from source (${claudeCount}/${sourceCount})`);
+  }
+
+  return {
+    ok: errors.length === 0,
+    errors,
+    warnings,
+    metrics: {
+      sourceAgents: sourceCount,
+      claudeAgents: claudeCount,
+    },
+  };
+}
+
+function formatHumanReport(result) {
+  if (result.ok) {
+    const lines = [`✅ Claude integration validation passed (agents: ${result.metrics.claudeAgents})`];
+    if (result.warnings.length > 0) {
+      lines.push(...result.warnings.map((w) => `⚠️ ${w}`));
+    }
+    return lines.join('\n');
+  }
+  const lines = [
+    `❌ Claude integration validation failed (${result.errors.length} issue(s))`,
+    ...result.errors.map((e) => `- ${e}`),
+  ];
+  if (result.warnings.length > 0) {
+    lines.push(...result.warnings.map((w) => `⚠️ ${w}`));
+  }
+  return lines.join('\n');
+}
+
+function main() {
+  const args = parseArgs();
+  const result = validateClaudeIntegration(args);
+
+  if (!args.quiet) {
+    if (args.json) {
+      console.log(JSON.stringify(result, null, 2));
+    } else {
+      console.log(formatHumanReport(result));
+    }
+  }
+
+  if (!result.ok) {
+    process.exitCode = 1;
+  }
+}
+
+if (require.main === module) {
+  main();
+}
+
+module.exports = {
+  validateClaudeIntegration,
+  parseArgs,
+  countMarkdownFiles,
+};

package/.aios-core/infrastructure/scripts/validate-codex-integration.js

@@ -0,0 +1,141 @@
+#!/usr/bin/env node
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+
+function getDefaultOptions() {
+  const projectRoot = process.cwd();
+  return {
+    projectRoot,
+    instructionsFile: path.join(projectRoot, 'AGENTS.md'),
+    agentsDir: path.join(projectRoot, '.codex', 'agents'),
+    skillsDir: path.join(projectRoot, '.codex', 'skills'),
+    sourceAgentsDir: path.join(projectRoot, '.aios-core', 'development', 'agents'),
+    quiet: false,
+    json: false,
+  };
+}
+
+function parseArgs(argv = process.argv.slice(2)) {
+  const args = new Set(argv);
+  return {
+    quiet: args.has('--quiet') || args.has('-q'),
+    json: args.has('--json'),
+  };
+}
+
+function countMarkdownFiles(dirPath) {
+  if (!fs.existsSync(dirPath)) return 0;
+  return fs.readdirSync(dirPath).filter((f) => f.endsWith('.md')).length;
+}
+
+function countSkillFiles(skillsDir) {
+  if (!fs.existsSync(skillsDir)) return 0;
+  const entries = fs.readdirSync(skillsDir, { withFileTypes: true });
+  return entries
+    .filter((entry) => entry.isDirectory() && entry.name.startsWith('aios-'))
+    .filter((entry) => fs.existsSync(path.join(skillsDir, entry.name, 'SKILL.md')))
+    .length;
+}
+
+function validateCodexIntegration(options = {}) {
+  const projectRoot = options.projectRoot || process.cwd();
+  const resolved = {
+    ...getDefaultOptions(),
+    ...options,
+    projectRoot,
+    instructionsFile: options.instructionsFile || path.join(projectRoot, 'AGENTS.md'),
+    agentsDir: options.agentsDir || path.join(projectRoot, '.codex', 'agents'),
+    skillsDir: options.skillsDir || path.join(projectRoot, '.codex', 'skills'),
+    sourceAgentsDir: options.sourceAgentsDir || path.join(projectRoot, '.aios-core', 'development', 'agents'),
+  };
+  const errors = [];
+  const warnings = [];
+
+  if (!fs.existsSync(resolved.instructionsFile)) {
+    warnings.push(
+      `Codex instructions file not found yet: ${path.relative(resolved.projectRoot, resolved.instructionsFile)}`,
+    );
+  }
+
+  if (!fs.existsSync(resolved.agentsDir)) {
+    errors.push(`Missing Codex agents dir: ${path.relative(resolved.projectRoot, resolved.agentsDir)}`);
+  }
+
+  if (!fs.existsSync(resolved.skillsDir)) {
+    errors.push(`Missing Codex skills dir: ${path.relative(resolved.projectRoot, resolved.skillsDir)}`);
+  }
+
+  const sourceCount = countMarkdownFiles(resolved.sourceAgentsDir);
+  const codexAgentsCount = countMarkdownFiles(resolved.agentsDir);
+  const codexSkillsCount = countSkillFiles(resolved.skillsDir);
+
+  if (sourceCount > 0 && codexAgentsCount !== sourceCount) {
+    warnings.push(`Codex agent count differs from source (${codexAgentsCount}/${sourceCount})`);
+  }
+
+  if (sourceCount > 0 && codexSkillsCount !== sourceCount) {
+    warnings.push(`Codex skill count differs from source (${codexSkillsCount}/${sourceCount})`);
+  }
+
+  return {
+    ok: errors.length === 0,
+    errors,
+    warnings,
+    metrics: {
+      sourceAgents: sourceCount,
+      codexAgents: codexAgentsCount,
+      codexSkills: codexSkillsCount,
+    },
+  };
+}
+
+function formatHumanReport(result) {
+  if (result.ok) {
+    const lines = [
+      `✅ Codex integration validation passed (agents: ${result.metrics.codexAgents}, skills: ${result.metrics.codexSkills})`,
+    ];
+    if (result.warnings.length > 0) {
+      lines.push(...result.warnings.map((w) => `⚠️ ${w}`));
+    }
+    return lines.join('\n');
+  }
+  const lines = [
+    `❌ Codex integration validation failed (${result.errors.length} issue(s))`,
+    ...result.errors.map((e) => `- ${e}`),
+  ];
+  if (result.warnings.length > 0) {
+    lines.push(...result.warnings.map((w) => `⚠️ ${w}`));
+  }
+  return lines.join('\n');
+}
+
+function main() {
+  const args = parseArgs();
+  const result = validateCodexIntegration(args);
+
+  if (!args.quiet) {
+    if (args.json) {
+      console.log(JSON.stringify(result, null, 2));
+    } else {
+      console.log(formatHumanReport(result));
+    }
+  }
+
+  if (!result.ok) {
+    process.exitCode = 1;
+  }
+}
+
+if (require.main === module) {
+  main();
+}
+
+module.exports = {
+  validateCodexIntegration,
+  parseArgs,
+  getDefaultOptions,
+  countMarkdownFiles,
+  countSkillFiles,
+};