agent-master-devsecops 0.0.0-stage → 5.1.0

package/scripts/core/universal_packager.js

@@ -0,0 +1,357 @@
+/**
+ * Universal Multi-Platform Packager & Profile Generator
+ * Exportador universal de perfis, manifestos e configurações do Agent Master DevSecOps
+ * para Cursor IDE, Windsurf, Claude Desktop, ChatGPT Custom GPTs e Ollama local.
+ * Conforme especificado em AGDEV-5 e README.md.
+ */
+
+const fs = require('node:fs');
+const path = require('node:path');
+const { version: PKG_VERSION } = require('../../package.json');
+const { generateCompactPrompt } = require('./context_compressor.js');
+const { createSarifReport } = require('./sarif_engine.js');
+
+const SUPPORTED_PLATFORMS = ['cursor', 'windsurf', 'vscode', 'claude_desktop', 'chatgpt', 'ollama', 'antigravity', 'all'];
+
+class UniversalPackager {
+  constructor(baseDir = path.resolve(__dirname, '../..')) {
+    this.baseDir = baseDir;
+  }
+
+  getCanonicalRules() {
+    const rulesPath = path.join(this.baseDir, 'docs', 'ENGINEERING_RULES.md');
+    if (fs.existsSync(rulesPath)) {
+      return fs.readFileSync(rulesPath, 'utf8');
+    }
+    return '10 Princípios Canônicos de Engenharia de Software & Governança';
+  }
+
+  getCompactPrompt() {
+    return generateCompactPrompt();
+  }
+
+  generateCursorProfile(targetDir, options = {}) {
+    const cursorRulesContent = `# Cursor Rules — Agent Master DevSecOps\n\n${this.getCompactPrompt()}`;
+    const mcpConfig = {
+      mcpServers: {
+        'agent-master-devsecops': {
+          command: 'node',
+          args: [options.mcpServerPath || path.resolve(this.baseDir, 'scripts', 'mcp_server.js')]
+        }
+      }
+    };
+
+    const files = [
+      { path: path.join(targetDir, '.cursorrules'), content: cursorRulesContent },
+      { path: path.join(targetDir, '.cursor', 'mcp.json'), content: JSON.stringify(mcpConfig, null, 2) }
+    ];
+
+    if (!options.dryRun) {
+      files.forEach(f => {
+        fs.mkdirSync(path.dirname(f.path), { recursive: true });
+        fs.writeFileSync(f.path, f.content, 'utf8');
+      });
+    }
+
+    return { platform: 'cursor', filesCount: files.length, files: files.map(f => f.path) };
+  }
+
+  generateWindsurfProfile(targetDir, options = {}) {
+    const content = `# Windsurf Rules — Agent Master DevSecOps\n\n${this.getCompactPrompt()}`;
+    const filePath = path.join(targetDir, '.windsurfrules');
+
+    if (!options.dryRun) {
+      fs.mkdirSync(targetDir, { recursive: true });
+      fs.writeFileSync(filePath, content, 'utf8');
+    }
+
+    return { platform: 'windsurf', filesCount: 1, files: [filePath] };
+  }
+
+  generateClaudeDesktopProfile(targetDir, options = {}) {
+    const mcpConfig = {
+      mcpServers: {
+        'agent-master-devsecops': {
+          command: 'node',
+          args: [options.mcpServerPath || path.resolve(this.baseDir, 'scripts', 'mcp_server.js')]
+        }
+      }
+    };
+    const filePath = path.join(targetDir, 'claude_desktop_config.json');
+
+    if (!options.dryRun) {
+      fs.mkdirSync(targetDir, { recursive: true });
+      fs.writeFileSync(filePath, JSON.stringify(mcpConfig, null, 2), 'utf8');
+    }
+
+    return { platform: 'claude_desktop', filesCount: 1, files: [filePath] };
+  }
+
+  generateChatGptProfile(targetDir, options = {}) {
+    const openApiSchema = {
+      openapi: '3.1.0',
+      info: {
+        title: 'Agent Master DevSecOps API',
+        version: PKG_VERSION,
+        description: 'Serviço de auditoria e governança autônoma DevSecOps para Custom GPTs.'
+      },
+      paths: {
+        '/audit': {
+          post: {
+            summary: 'Audita código contra os 10 Princípios Canônicos e OWASP',
+            operationId: 'auditCode',
+            responses: { '200': { description: 'Relatório de auditoria' } }
+          }
+        }
+      }
+    };
+
+    const files = [
+      { path: path.join(targetDir, 'chatgpt_custom_instructions.md'), content: this.getCompactPrompt() },
+      { path: path.join(targetDir, 'agent_master_openapi.json'), content: JSON.stringify(openApiSchema, null, 2) }
+    ];
+
+    if (!options.dryRun) {
+      files.forEach(f => {
+        fs.mkdirSync(path.dirname(f.path), { recursive: true });
+        fs.writeFileSync(f.path, f.content, 'utf8');
+      });
+    }
+
+    return { platform: 'chatgpt', filesCount: files.length, files: files.map(f => f.path) };
+  }
+
+  generateOllamaProfile(targetDir, options = {}) {
+    const baseModel = options.baseModel || 'qwen2.5-coder:7b';
+    const modelfileContent = 'FROM ' + baseModel + '\n\nSYSTEM """\n' + this.getCompactPrompt() + '\n"""\n\nPARAMETER temperature 0.2\n';
+    const filePath = path.join(targetDir, 'Modelfile');
+
+    if (!options.dryRun) {
+      fs.mkdirSync(targetDir, { recursive: true });
+      fs.writeFileSync(filePath, modelfileContent, 'utf8');
+    }
+
+    return { platform: 'ollama', filesCount: 1, files: [filePath] };
+  }
+
+  generateAntigravityConfig(targetDir, options = {}) {
+    const homeDir = process.env.USERPROFILE || process.env.HOME || '';
+    const mcpServerPath = options.mcpServerPath || path.resolve(this.baseDir, 'scripts', 'mcp_server.js');
+    const geminiConfigDir = path.join(homeDir, '.gemini', 'config');
+    const mcpConfigPath = path.join(geminiConfigDir, 'mcp_config.json');
+
+    const files = [];
+
+    if (!options.dryRun) {
+      if (!fs.existsSync(geminiConfigDir)) {
+        fs.mkdirSync(geminiConfigDir, { recursive: true });
+      }
+
+      let mcpJson = { mcpServers: {} };
+      if (fs.existsSync(mcpConfigPath)) {
+        try {
+          mcpJson = JSON.parse(fs.readFileSync(mcpConfigPath, 'utf8'));
+          if (!mcpJson.mcpServers) mcpJson.mcpServers = {};
+        } catch (err) {
+          mcpJson = { mcpServers: {} };
+          void err;
+        }
+      }
+
+      mcpJson.mcpServers['agent-master-devsecops'] = {
+        command: 'node',
+        args: [mcpServerPath]
+      };
+
+      fs.writeFileSync(mcpConfigPath, JSON.stringify(mcpJson, null, 2), 'utf8');
+      files.push(mcpConfigPath);
+    }
+
+    return { platform: 'antigravity', filesCount: 1, files };
+  }
+
+  generateVsCodeProfile(targetDir, options = {}) {
+    const vscodeDir = path.join(targetDir, '.vscode');
+    const mcpConfigPath = path.join(vscodeDir, 'mcp.json');
+    const mcpConfig = {
+      mcpServers: {
+        'agent-master-devsecops': {
+          command: 'node',
+          args: [options.mcpServerPath || path.resolve(this.baseDir, 'scripts', 'mcp_server.js')]
+        }
+      }
+    };
+
+    const files = [mcpConfigPath];
+    if (!options.dryRun) {
+      if (!fs.existsSync(vscodeDir)) fs.mkdirSync(vscodeDir, { recursive: true });
+      fs.writeFileSync(mcpConfigPath, JSON.stringify(mcpConfig, null, 2), 'utf8');
+    }
+
+    return { platform: 'vscode', filesCount: 1, files };
+  }
+
+  exportProfile(platform, targetDir, options = {}) {
+    const cleanPlatform = String(platform).toLowerCase();
+    switch (cleanPlatform) {
+      case 'cursor':
+        return this.generateCursorProfile(targetDir, options);
+      case 'windsurf':
+        return this.generateWindsurfProfile(targetDir, options);
+      case 'vscode':
+      case 'code':
+        return this.generateVsCodeProfile(targetDir, options);
+      case 'claude_desktop':
+      case 'claude':
+        return this.generateClaudeDesktopProfile(targetDir, options);
+      case 'chatgpt':
+        return this.generateChatGptProfile(targetDir, options);
+      case 'ollama':
+        return this.generateOllamaProfile(targetDir, options);
+      case 'antigravity':
+      case 'gemini':
+        return this.generateAntigravityConfig(targetDir, options);
+      case 'all': {
+        const r1 = this.generateCursorProfile(targetDir, options);
+        const r2 = this.generateWindsurfProfile(targetDir, options);
+        const r3 = this.generateClaudeDesktopProfile(targetDir, options);
+        const r4 = this.generateChatGptProfile(targetDir, options);
+        const r5 = this.generateOllamaProfile(targetDir, options);
+        const r6 = this.generateVsCodeProfile(targetDir, options);
+        const r7 = this.generateAntigravityConfig(targetDir, options);
+        return {
+          platform: 'all',
+          totalFiles: r1.filesCount + r2.filesCount + r3.filesCount + r4.filesCount + r5.filesCount + r6.filesCount + r7.filesCount,
+          results: [r1, r2, r3, r4, r5, r6, r7]
+        };
+      }
+      default:
+        throw new Error(`Plataforma não suportada: "${platform}". Plataformas suportadas: ${SUPPORTED_PLATFORMS.join(', ')}`);
+    }
+  }
+
+  auditToSarif(targetPlatform = 'all') {
+    const findings = [];
+    const supported = SUPPORTED_PLATFORMS.includes(String(targetPlatform).toLowerCase());
+
+    if (!supported) {
+      findings.push({
+        ruleId: 'RULE-PKG-001',
+        name: 'UnsupportedPackagingPlatform',
+        severity: 'WARNING',
+        message: `Plataforma "${targetPlatform}" não é suportada nativamente.`,
+        remediation: `Utilize uma das plataformas homologadas: ${SUPPORTED_PLATFORMS.join(', ')}.`
+      });
+    }
+
+    return createSarifReport({
+      toolName: 'agent-master-universal-packager',
+      rules: [
+        {
+          id: 'RULE-PKG-001',
+          name: 'UnsupportedPackagingPlatform',
+          description: 'Identifica tentativas de exportação para plataformas sem blueprint homologado',
+          severity: 'MEDIUM',
+          cwe: 'CWE-400'
+        }
+      ],
+      findings,
+      properties: {
+        platform: targetPlatform,
+        supportedPlatforms: SUPPORTED_PLATFORMS
+      }
+    });
+  }
+
+  formatReport() {
+    return [
+      '### Relatório de Empacotador Universal de Perfis & IDEs',
+      `- **Plataformas Homologadas:** \`${SUPPORTED_PLATFORMS.join('`, `')}\``,
+      `- **Modo MCP Padrão:** stdio via \`scripts/mcp_server.js\``,
+      `- **Suporte:** Cursor, Windsurf, Claude Desktop, Antigravity, VS Code, Ollama, ChatGPT`
+    ].join('\n');
+  }
+}
+
+
+function generateVsCodeSettings() {
+  return {
+    "mcp.servers": {
+      "agent-master-devsecops": {
+        "command": "node",
+        "args": ["${workspaceFolder}/node_modules/agent-master-devsecops/scripts/mcp_server.js"]
+      }
+    },
+    "customInstructions": [
+      {
+        "role": "system",
+        "content": "Siga rigorosamente as 15 Regras de Engenharia da suíte multi-agente e responda no formato de saída compacta com links diretos."
+      }
+    ],
+    "shortcuts": {
+      "orchestrator": "modo: orchestrator",
+      "devsecops": "modo: devsecops",
+      "qa": "modo: qa",
+      "scrum": "modo: scrum",
+      "sre": "modo: sre",
+      "full-dev": "modo: full-dev"
+    }
+  };
+}
+
+function generateJetBrainsConfig() {
+  return {
+    "agentMasterDevSecOps": {
+      "version": PKG_VERSION,
+      "mcpEnabled": true,
+      "mcpTransport": "stdio",
+      "mcpCommand": "node scripts/mcp_server.js",
+      "modes": ["orchestrator", "devsecops", "qa", "scrum", "sre", "full-dev"],
+      "ruleSet": "docs/ENGINEERING_RULES.md",
+      "dualLayerOutput": true
+    }
+  };
+}
+
+function exportIdeConfigs(targetDir, options = {}) {
+  const results = {
+    vscodeConfigured: false,
+    jetbrainsConfigured: false
+  };
+
+  const vscodeDir = path.join(targetDir, '.vscode');
+  const jetbrainsDir = path.join(targetDir, '.idea');
+
+  if (!options.dryRun) {
+    if (!fs.existsSync(vscodeDir)) fs.mkdirSync(vscodeDir, { recursive: true });
+    if (!fs.existsSync(jetbrainsDir)) fs.mkdirSync(jetbrainsDir, { recursive: true });
+
+    fs.writeFileSync(
+      path.join(vscodeDir, 'agent-master.json'),
+      JSON.stringify(generateVsCodeSettings(), null, 2),
+      'utf8'
+    );
+    results.vscodeConfigured = true;
+
+    fs.writeFileSync(
+      path.join(jetbrainsDir, 'agent-master.json'),
+      JSON.stringify(generateJetBrainsConfig(), null, 2),
+      'utf8'
+    );
+    results.jetbrainsConfigured = true;
+  } else {
+    results.vscodeConfigured = true;
+    results.jetbrainsConfigured = true;
+  }
+
+  return results;
+}
+
+module.exports = {
+  UniversalPackager,
+  SUPPORTED_PLATFORMS,
+  generateVsCodeSettings,
+  generateJetBrainsConfig,
+  exportIdeConfigs,
+  generateIdeConfigs: exportIdeConfigs
+};