sinapse-ai 7.7.2 → 7.7.4

package/.sinapse-ai/infrastructure/scripts/validate-codex-command-registry.js

@@ -0,0 +1,264 @@
+#!/usr/bin/env node
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+
+const REQUIRED_COMMAND_COVERAGE = Object.freeze({
+  'sinapse-orqx': ['onboard', 'route', 'plan', 'status', 'brief', 'resolve', 'council'],
+  'sinapse-pm': [
+    'create-prd',
+    'create-brownfield-prd',
+    'create-epic',
+    'create-story',
+    'research',
+    'execute-epic',
+    'gather-requirements',
+    'write-spec',
+    'shard-prd',
+  ],
+  'sinapse-po': [
+    'validate-story',
+    'validate-story-draft',
+    'backlog-review',
+    'backlog-prioritize',
+    'backlog-schedule',
+    'close-story',
+    'sync-story',
+    'pull-story',
+    'stories-index',
+  ],
+  'sinapse-sm': ['draft', 'story-checklist'],
+  'sinapse-dev': [
+    'develop',
+    'run-tests',
+    'apply-qa-fixes',
+    'execute-subtask',
+    'verify-subtask',
+    'build-autonomous',
+    'build-resume',
+    'build-status',
+    'build',
+  ],
+  'sinapse-qa': [
+    'review',
+    'review-story',
+    'code-review',
+    'gate',
+    'review-build',
+    'create-fix-request',
+    'test-design',
+    'generate-tests',
+    'run-tests',
+    'nfr-assess',
+    'validate-libraries',
+    'security-check',
+    'validate-migrations',
+    'evidence-check',
+    'false-positive-check',
+    'console-check',
+  ],
+});
+
+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 normalizeAgentAlias(value) {
+  return String(value || '').trim().replace(/^@/, '').toLowerCase();
+}
+
+function normalizeCommandAlias(value) {
+  return String(value || '').trim().replace(/^\*/, '').toLowerCase();
+}
+
+function collectAgentAliases(agentId, agentSpec) {
+  return [agentId, ...(agentSpec.aliases || [])]
+    .map((alias) => normalizeAgentAlias(alias))
+    .filter(Boolean);
+}
+
+function collectCommandAliases(commandId, commandSpec) {
+  return [commandId, ...(commandSpec.aliases || [])]
+    .map((alias) => normalizeCommandAlias(alias))
+    .filter(Boolean);
+}
+
+function loadRegistry(projectRoot) {
+  const registryPath = path.join(projectRoot, '.codex', 'command-registry.json');
+  if (!fs.existsSync(registryPath)) {
+    return {
+      registryPath,
+      registry: null,
+      error: `Missing Codex command registry: ${path.relative(projectRoot, registryPath)}`,
+    };
+  }
+
+  try {
+    return {
+      registryPath,
+      registry: JSON.parse(fs.readFileSync(registryPath, 'utf8')),
+      error: null,
+    };
+  } catch (error) {
+    return {
+      registryPath,
+      registry: null,
+      error: `Unable to parse Codex command registry: ${error.message}`,
+    };
+  }
+}
+
+function validateRequiredCoverage(registry, requiredCoverage, errors) {
+  for (const [agentId, requiredCommands] of Object.entries(requiredCoverage || {})) {
+    const agentSpec = (registry.agents || {})[agentId];
+    if (!agentSpec) {
+      errors.push(`missing required agent coverage: ${agentId}`);
+      continue;
+    }
+
+    const availableCommands = new Set();
+    for (const [commandId, commandSpec] of Object.entries(agentSpec.commands || {})) {
+      for (const alias of collectCommandAliases(commandId, commandSpec)) {
+        availableCommands.add(alias);
+      }
+    }
+
+    for (const requiredCommand of requiredCommands) {
+      if (!availableCommands.has(normalizeCommandAlias(requiredCommand))) {
+        errors.push(`${agentId}: missing required command coverage for ${requiredCommand}`);
+      }
+    }
+  }
+}
+
+function validateCodexCommandRegistry(options = {}) {
+  const projectRoot = options.projectRoot || process.cwd();
+  const { registryPath, registry, error } = loadRegistry(projectRoot);
+  const errors = [];
+  const requiredCoverage =
+    options.requiredCoverage === false
+      ? null
+      : options.requiredCoverage || REQUIRED_COMMAND_COVERAGE;
+
+  if (error) {
+    errors.push(error);
+    return {
+      ok: false,
+      errors,
+      warnings: [],
+      metrics: { agents: 0, commands: 0 },
+    };
+  }
+
+  let commandCount = 0;
+  const seenAgentAliases = new Map();
+  for (const [agentId, agentSpec] of Object.entries(registry.agents || {})) {
+    const skillPath = path.join(projectRoot, '.codex', 'skills', agentSpec.skillId || agentId, 'SKILL.md');
+    if (!fs.existsSync(skillPath)) {
+      errors.push(`${agentId}: missing skill file ${path.relative(projectRoot, skillPath)}`);
+    }
+
+    const sourceOfTruth = path.join(projectRoot, agentSpec.sourceOfTruth || '');
+    if (!fs.existsSync(sourceOfTruth)) {
+      errors.push(`${agentId}: missing source of truth ${path.relative(projectRoot, sourceOfTruth)}`);
+    }
+
+    for (const alias of collectAgentAliases(agentId, agentSpec)) {
+      const owner = seenAgentAliases.get(alias);
+      if (owner && owner !== agentId) {
+        errors.push(`duplicate agent alias "${alias}" claimed by ${owner} and ${agentId}`);
+      } else {
+        seenAgentAliases.set(alias, agentId);
+      }
+    }
+
+    const seenCommandAliases = new Map();
+    for (const [commandId, commandSpec] of Object.entries(agentSpec.commands || {})) {
+      commandCount += 1;
+
+      const targetPath = path.join(projectRoot, commandSpec.target || '');
+      if (!fs.existsSync(targetPath)) {
+        errors.push(`${agentId}.${commandId}: missing target ${path.relative(projectRoot, targetPath)}`);
+      }
+
+      for (const resource of commandSpec.resources || []) {
+        const resourcePath = path.join(projectRoot, resource);
+        if (!fs.existsSync(resourcePath)) {
+          errors.push(`${agentId}.${commandId}: missing resource ${path.relative(projectRoot, resourcePath)}`);
+        }
+      }
+
+      for (const alias of collectCommandAliases(commandId, commandSpec)) {
+        const owner = seenCommandAliases.get(alias);
+        if (owner && owner !== commandId) {
+          errors.push(`${agentId}: duplicate command alias "${alias}" claimed by ${owner} and ${commandId}`);
+        } else {
+          seenCommandAliases.set(alias, commandId);
+        }
+      }
+    }
+  }
+
+  validateRequiredCoverage(registry, requiredCoverage, errors);
+
+  return {
+    ok: errors.length === 0,
+    errors,
+    warnings: [],
+    metrics: {
+      agents: Object.keys(registry.agents || {}).length,
+      commands: commandCount,
+      registryPath: path.relative(projectRoot, registryPath),
+    },
+  };
+}
+
+function formatHumanReport(result) {
+  if (result.ok) {
+    return `OK Codex command registry validation passed (agents: ${result.metrics.agents}, commands: ${result.metrics.commands})`;
+  }
+
+  return [
+    `X Codex command registry validation failed (${result.errors.length} issue(s))`,
+    ...result.errors.map((error) => `- ${error}`),
+  ].join('\n');
+}
+
+function main() {
+  const args = parseArgs();
+  const result = validateCodexCommandRegistry(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 = {
+  parseArgs,
+  loadRegistry,
+  normalizeAgentAlias,
+  normalizeCommandAlias,
+  collectAgentAliases,
+  collectCommandAliases,
+  validateRequiredCoverage,
+  validateCodexCommandRegistry,
+  formatHumanReport,
+  REQUIRED_COMMAND_COVERAGE,
+};

package/.sinapse-ai/infrastructure/scripts/validate-codex-integration.js

@@ -3,6 +3,10 @@
 
 const fs = require('fs');
 const path = require('path');
+const {
+  loadCodexCatalogConfig,
+  getConfiguredSkillIds,
+} = require('./codex-parity/catalog');
 
 function getDefaultOptions() {
   const projectRoot = process.cwd();
@@ -41,14 +45,15 @@ function countSkillFiles(skillsDir) {
 
 function validateCodexIntegration(options = {}) {
   const projectRoot = options.projectRoot || process.cwd();
+  const config = loadCodexCatalogConfig(projectRoot);
   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, '.sinapse-ai', 'development', 'agents'),
+    agentsDir: options.agentsDir || path.join(projectRoot, config.codexAgentsDir || '.codex/agents'),
+    skillsDir: options.skillsDir || path.join(projectRoot, config.skillsDir || '.codex/skills'),
+    sourceAgentsDir: options.sourceAgentsDir || path.join(projectRoot, config.canonicalAgentsDir || '.sinapse-ai/development/agents'),
   };
   const errors = [];
   const warnings = [];
@@ -70,12 +75,15 @@ function validateCodexIntegration(options = {}) {
   const sourceCount = countMarkdownFiles(resolved.sourceAgentsDir);
   const codexAgentsCount = countMarkdownFiles(resolved.agentsDir);
   const codexSkillsCount = countSkillFiles(resolved.skillsDir);
+  const expectedSkillIds = getConfiguredSkillIds(config);
 
-  if (sourceCount > 0 && codexAgentsCount !== sourceCount) {
+  if (config.catalogMode !== 'expanded' && sourceCount > 0 && codexAgentsCount !== sourceCount) {
     warnings.push(`Codex agent count differs from source (${codexAgentsCount}/${sourceCount})`);
   }
 
-  if (sourceCount > 0 && codexSkillsCount !== sourceCount) {
+  if (expectedSkillIds && codexSkillsCount !== expectedSkillIds.length) {
+    warnings.push(`Codex skill count differs from configured catalog (${codexSkillsCount}/${expectedSkillIds.length})`);
+  } else if (!expectedSkillIds && sourceCount > 0 && codexSkillsCount !== sourceCount) {
     warnings.push(`Codex skill count differs from source (${codexSkillsCount}/${sourceCount})`);
   }
 
@@ -84,9 +92,10 @@ function validateCodexIntegration(options = {}) {
     errors,
     warnings,
     metrics: {
-      sourceAgents: sourceCount,
+      canonicalAgents: sourceCount,
       codexAgents: codexAgentsCount,
       codexSkills: codexSkillsCount,
+      expectedSkills: expectedSkillIds ? expectedSkillIds.length : sourceCount,
     },
   };
 }

package/.sinapse-ai/infrastructure/scripts/validate-codex-sync.js

@@ -0,0 +1,156 @@
+#!/usr/bin/env node
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const { spawnSync } = require('child_process');
+const { loadCodexCatalogConfig } = require('./codex-parity/catalog');
+const { validateCodexCommandRegistry } = require('./validate-codex-command-registry');
+const { validateCodexIntegration } = require('./validate-codex-integration');
+const { validateCodexSkills } = require('./codex-skills-sync/validate');
+const { validatePaths } = require('./validate-paths');
+
+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 runLegacyCodexValidate(projectRoot, options = {}) {
+  const args = [
+    path.join('.sinapse-ai', 'infrastructure', 'scripts', 'ide-sync', 'index.js'),
+    'validate',
+    '--ide',
+    'codex',
+    '--strict',
+  ];
+
+  if (options.quiet) args.push('--quiet');
+
+  const result = spawnSync(process.execPath, args, {
+    cwd: projectRoot,
+    encoding: 'utf8',
+  });
+
+  return {
+    ok: result.status === 0,
+    mode: 'canonical',
+    checks: [],
+    errors: result.status === 0 ? [] : ['Legacy Codex sync validation failed'],
+    warnings: [],
+    raw: [result.stdout, result.stderr].filter(Boolean).join('\n').trim(),
+  };
+}
+
+function normalizeCheck(id, input) {
+  return {
+    id,
+    ok: Boolean(input?.ok),
+    errors: Array.isArray(input?.errors) ? input.errors : [],
+    warnings: Array.isArray(input?.warnings) ? input.warnings : [],
+    metrics: input?.metrics || {},
+  };
+}
+
+function validateCodexSync(options = {}, deps = {}) {
+  const projectRoot = options.projectRoot || process.cwd();
+  const config = loadCodexCatalogConfig(projectRoot);
+  const runLegacyValidate = deps.runLegacyCodexValidate || runLegacyCodexValidate;
+  const runCodexCommands = deps.validateCodexCommandRegistry || validateCodexCommandRegistry;
+  const runCodexIntegration = deps.validateCodexIntegration || validateCodexIntegration;
+  const runCodexSkills = deps.validateCodexSkills || validateCodexSkills;
+  const runPaths = deps.validatePaths || validatePaths;
+
+  if (config.catalogMode !== 'expanded') {
+    return runLegacyValidate(projectRoot, options);
+  }
+
+  const catalogPath = path.join(projectRoot, '.codex', 'catalog.json');
+  const checks = [
+    normalizeCheck('codex-integration', runCodexIntegration({ projectRoot, quiet: true })),
+    normalizeCheck('codex-commands', runCodexCommands({ projectRoot, quiet: true })),
+    normalizeCheck('codex-skills', runCodexSkills({ projectRoot, strict: true, quiet: true })),
+    normalizeCheck('paths', runPaths({ projectRoot, quiet: true })),
+  ];
+
+  if (!fs.existsSync(catalogPath)) {
+    checks.unshift({
+      id: 'codex-catalog',
+      ok: false,
+      errors: ['Missing Codex catalog file: .codex/catalog.json'],
+      warnings: [],
+      metrics: {},
+    });
+  } else {
+    checks.unshift({
+      id: 'codex-catalog',
+      ok: true,
+      errors: [],
+      warnings: [],
+      metrics: {},
+    });
+  }
+
+  return {
+    ok: checks.every((check) => check.ok),
+    mode: 'expanded',
+    checks,
+    errors: checks.flatMap((check) => check.errors.map((error) => `${check.id}: ${error}`)),
+    warnings: checks.flatMap((check) => check.warnings.map((warning) => `${check.id}: ${warning}`)),
+  };
+}
+
+function formatHumanReport(result) {
+  if (result.mode === 'canonical' && result.raw) {
+    return result.raw;
+  }
+
+  const lines = [
+    result.ok
+      ? 'OK Codex sync validation passed'
+      : `X Codex sync validation failed (${result.errors.length} issue(s))`,
+  ];
+
+  for (const check of result.checks || []) {
+    lines.push(`${check.ok ? 'OK' : 'X'} ${check.id}`);
+    if (check.errors.length > 0) {
+      lines.push(...check.errors.map((error) => `- ${error}`));
+    }
+    if (check.warnings.length > 0) {
+      lines.push(...check.warnings.map((warning) => `! ${warning}`));
+    }
+  }
+
+  return lines.join('\n');
+}
+
+function main() {
+  const args = parseArgs();
+  const result = validateCodexSync(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 = {
+  parseArgs,
+  validateCodexSync,
+  formatHumanReport,
+  runLegacyCodexValidate,
+  normalizeCheck,
+};

package/.sinapse-ai/infrastructure/scripts/validate-parity.js

@@ -6,6 +6,7 @@ const path = require('path');
 const yaml = require('js-yaml');
 const { spawnSync } = require('child_process');
 const { validateClaudeIntegration } = require('./validate-claude-integration');
+const { validateCodexSync } = require('./validate-codex-sync');
 const { validateCodexIntegration } = require('./validate-codex-integration');
 const { validateCodexSkills } = require('./codex-skills-sync/validate');
 const { validatePaths } = require('./validate-paths');
@@ -218,6 +219,7 @@ function diffCompatibilityContracts(currentContract, previousContract) {
 function runParityValidation(options = {}, deps = {}) {
   const projectRoot = options.projectRoot || process.cwd();
   const runSync = deps.runSyncValidate || runSyncValidate;
+  const runCodexSync = deps.validateCodexSync || validateCodexSync;
   const runClaudeIntegration = deps.validateClaudeIntegration || validateClaudeIntegration;
   const runCodexIntegration = deps.validateCodexIntegration || validateCodexIntegration;
   const runCodexSkills = deps.validateCodexSkills || validateCodexSkills;
@@ -234,7 +236,7 @@ function runParityValidation(options = {}, deps = {}) {
   const checks = [
     { id: 'claude-sync', exec: () => runSync('claude-code', projectRoot) },
     { id: 'claude-integration', exec: () => runClaudeIntegration({ projectRoot }) },
-    { id: 'codex-sync', exec: () => runSync('codex', projectRoot) },
+    { id: 'codex-sync', exec: () => runCodexSync({ projectRoot, quiet: true }) },
     { id: 'codex-integration', exec: () => runCodexIntegration({ projectRoot }) },
     { id: 'codex-skills', exec: () => runCodexSkills({ projectRoot, strict: true, quiet: true }) },
     { id: 'paths', exec: () => runPaths({ projectRoot }) },

package/.sinapse-ai/infrastructure/scripts/validate-paths.js

@@ -3,6 +3,10 @@
 
 const fs = require('fs');
 const path = require('path');
+const {
+  loadCodexCatalogConfig,
+  validateSkillActivationPaths,
+} = require('./codex-parity/catalog');
 
 const FORBIDDEN_ABSOLUTE_PATTERNS = [
   /\/Users\/[^\s/'"]+/g,
@@ -54,21 +58,15 @@ function collectAbsolutePathViolations(content, filePath) {
   return errors;
 }
 
-function validateSkillPathConventions(content, filePath) {
-  const errors = [];
-  if (!content.includes('.sinapse-ai/development/agents/')) {
-    errors.push(`${filePath} missing canonical source path ".sinapse-ai/development/agents/"`);
-  }
-  if (!content.includes('.sinapse-ai/development/scripts/generate-greeting.js')) {
-    errors.push(`${filePath} missing canonical greeting script path`);
-  }
-  return errors;
+function validateSkillPathConventions(content, filePath, config) {
+  return validateSkillActivationPaths(content, filePath, config);
 }
 
 function validatePaths(options = {}) {
   const resolved = { ...getDefaultOptions(), ...options };
   const errors = [];
   const checkedFiles = [];
+  const config = loadCodexCatalogConfig(resolved.projectRoot);
 
   const skillFiles = listSkillFiles(resolved.skillsDir);
   const filesToCheck = [...resolved.requiredFiles, ...skillFiles];
@@ -90,7 +88,7 @@ function validatePaths(options = {}) {
     errors.push(...collectAbsolutePathViolations(content, path.relative(resolved.projectRoot, file)));
 
     if (file.endsWith('SKILL.md')) {
-      errors.push(...validateSkillPathConventions(content, path.relative(resolved.projectRoot, file)));
+      errors.push(...validateSkillPathConventions(content, path.relative(resolved.projectRoot, file), config));
     }
   }
 

package/.sinapse-ai/infrastructure/templates/safe-collab/README.md

@@ -2,38 +2,73 @@
 
 Template reutilizavel para configurar colaboracao segura em qualquer projeto.
 
-## Uso
+## Fonte canonica
 
-Copie os arquivos deste diretorio para o projeto alvo:
+Para a politica completa e atualizada de colaboracao paralela, use:
 
-```bash
-# 1. Regra para agentes Claude Code
-cp safe-collaboration-rule.md <projeto>/.claude/rules/safe-collaboration.md
+- `docs/guides/parallel-collaboration-source-of-truth.md`
+
+Este README explica o template. O documento acima define a regra mestra.
+
+## Uso rapido
 
-# 2. Guia para a equipe
-cp parallel-workflow-guide.md <projeto>/docs/guides/parallel-workflow.md
+```bash
+bash apply.sh <projeto> <owner-github> <collab-github> [prefix1] [prefix2]
+```
 
-# 3. CODEOWNERS (ajuste os usernames)
-cp CODEOWNERS.template <projeto>/.github/CODEOWNERS
+### Exemplo
 
-# 4. PR template simplificado
-cp pull_request_template.md <projeto>/.github/PULL_REQUEST_TEMPLATE.md
+```bash
+bash .sinapse-ai/infrastructure/templates/safe-collab/apply.sh \
+  /path/to/meu-projeto \
+  caioimori \
+  Matheus-soier \
+  caio \
+  soier
 ```
 
-## Configuracao no GitHub
+Isso cria automaticamente:
+- `.claude/rules/safe-collaboration.md` — regras para agentes
+- `.github/PULL_REQUEST_TEMPLATE.md` — template simplificado de PR
+- `.github/CODEOWNERS` — code owners configurado
+- `docs/guides/parallel-workflow.md` — guia para equipe
+- Atualiza `.gitignore` com patterns de runtime
 
-Apos copiar os arquivos, configure no repositorio:
+## Configuracao manual no GitHub
 
-1. Settings > Rules > Rulesets > New ruleset
-   - Target: `main`
+Apos rodar o script, configure no repositorio:
+
+1. **Settings > Rules > Rulesets > New ruleset** (target: `main`)
    - Block direct pushes
    - Require 1 PR approval
    - Block force pushes
    - Block branch deletion
    - Dismiss stale reviews
 
-2. Settings > Collaborators
+2. **Settings > Collaborators**
    - Adicionar membros com permissao `Write` (nunca Admin)
 
-3. Settings > General
+3. **Settings > General**
    - Marcar "Automatically delete head branches"
+
+## Arquivos incluidos
+
+| Arquivo | Proposito |
+|---------|-----------|
+| `apply.sh` | Script de aplicacao automatica |
+| `safe-collaboration-rule.md` | Regra para `.claude/rules/` |
+| `parallel-workflow-guide.md` | Guia para equipe |
+| `CODEOWNERS.template` | Template de code owners |
+| `pull_request_template.md` | PR template simplificado |
+
+## Placeholders
+
+| Placeholder | Descricao | Exemplo |
+|-------------|-----------|---------|
+| `{{USER_1}}` | Nome do usuario 1 | Caio |
+| `{{USER_2}}` | Nome do usuario 2 | Matheus |
+| `{{user1}}` | Prefixo de branch user 1 | caio |
+| `{{user2}}` | Prefixo de branch user 2 | soier |
+| `{{OWNER_GITHUB}}` | Username GitHub do owner | caioimori |
+| `{{COLLAB_GITHUB}}` | Username GitHub do collab | Matheus-soier |
+| `{{PROJECT_NAME}}` | Nome do projeto | meu-projeto |