aiox-core 5.0.7 → 5.0.8

package/.aiox-core/infrastructure/scripts/repair-agent-references.js

@@ -0,0 +1,263 @@
+#!/usr/bin/env node
+'use strict';
+
+const fs = require('fs-extra');
+const path = require('path');
+
+const { parseAllAgents } = require('./ide-sync/agent-parser');
+const { commandSync } = require('./ide-sync/index');
+const {
+  syncSkills,
+  getCodexHome,
+  getSkillId,
+  getLegacySkillId,
+} = require('./codex-skills-sync/index');
+const { validateCodexSkills } = require('./codex-skills-sync/validate');
+
+function getDefaultOptions() {
+  const projectRoot = process.cwd();
+  return {
+    projectRoot,
+    sourceDir: path.join(projectRoot, '.aiox-core', 'development', 'agents'),
+    localSkillsDir: path.join(projectRoot, '.codex', 'skills'),
+    globalSkillsDir: path.join(getCodexHome(), 'skills'),
+    geminiCommandsDir: path.join(projectRoot, '.gemini', 'commands'),
+    includeGlobal: true,
+    dryRun: false,
+    quiet: false,
+    json: false,
+  };
+}
+
+function parseArgs(argv = process.argv.slice(2)) {
+  const args = new Set(argv);
+  return {
+    includeGlobal: !args.has('--no-global'),
+    dryRun: args.has('--dry-run'),
+    quiet: args.has('--quiet') || args.has('-q'),
+    json: args.has('--json'),
+  };
+}
+
+function isParsableAgent(agent) {
+  return !agent.error || agent.error === 'YAML parse failed, using fallback extraction';
+}
+
+function buildLegacyArtifacts(agents, options) {
+  const artifacts = [];
+
+  for (const agent of agents) {
+    const canonicalSkillId = getSkillId(agent.id);
+    const legacySkillId = getLegacySkillId(agent.id);
+
+    artifacts.push({
+      kind: 'skill-dir',
+      scope: 'local',
+      canonicalId: canonicalSkillId,
+      legacyId: legacySkillId,
+      path: path.join(options.localSkillsDir, legacySkillId),
+    });
+
+    if (options.includeGlobal) {
+      artifacts.push({
+        kind: 'skill-dir',
+        scope: 'global',
+        canonicalId: canonicalSkillId,
+        legacyId: legacySkillId,
+        path: path.join(options.globalSkillsDir, legacySkillId),
+      });
+    }
+
+    artifacts.push({
+      kind: 'gemini-command',
+      scope: 'project',
+      canonicalId: canonicalSkillId,
+      legacyId: legacySkillId,
+      path: path.join(options.geminiCommandsDir, `${legacySkillId}.toml`),
+    });
+  }
+
+  artifacts.push({
+    kind: 'gemini-menu',
+    scope: 'project',
+    canonicalId: 'aiox-menu',
+    legacyId: 'aios-menu',
+    path: path.join(options.geminiCommandsDir, 'aios-menu.toml'),
+  });
+
+  return artifacts;
+}
+
+function removeLegacyArtifacts(artifacts, options) {
+  const removed = [];
+  const skipped = [];
+
+  for (const artifact of artifacts) {
+    if (!fs.existsSync(artifact.path)) {
+      skipped.push({ ...artifact, reason: 'not-found' });
+      continue;
+    }
+
+    if (!options.dryRun) {
+      fs.removeSync(artifact.path);
+    }
+
+    removed.push(artifact);
+  }
+
+  return { removed, skipped };
+}
+
+function validateGeminiCommands(agents, commandsDir) {
+  const errors = [];
+  const checked = [];
+
+  const menuPath = path.join(commandsDir, 'aiox-menu.toml');
+  checked.push(menuPath);
+  if (!fs.existsSync(menuPath)) {
+    errors.push(`Missing Gemini launcher: ${menuPath}`);
+  }
+
+  const legacyMenuPath = path.join(commandsDir, 'aios-menu.toml');
+  if (fs.existsSync(legacyMenuPath)) {
+    errors.push(`Legacy Gemini launcher still present: ${legacyMenuPath}`);
+  }
+
+  for (const agent of agents) {
+    const canonicalId = getSkillId(agent.id);
+    const legacyId = getLegacySkillId(agent.id);
+    const canonicalPath = path.join(commandsDir, `${canonicalId}.toml`);
+    const legacyPath = path.join(commandsDir, `${legacyId}.toml`);
+
+    checked.push(canonicalPath);
+    if (!fs.existsSync(canonicalPath)) {
+      errors.push(`Missing Gemini command: ${canonicalPath}`);
+    }
+    if (fs.existsSync(legacyPath)) {
+      errors.push(`Legacy Gemini command still present: ${legacyPath}`);
+    }
+  }
+
+  return {
+    ok: errors.length === 0,
+    checked: checked.length,
+    errors,
+  };
+}
+
+async function repairAgentReferences(options = {}) {
+  const resolved = { ...getDefaultOptions(), ...options };
+  const agents = parseAllAgents(resolved.sourceDir).filter(isParsableAgent);
+  const legacyArtifacts = buildLegacyArtifacts(agents, resolved);
+  const cleanup = removeLegacyArtifacts(legacyArtifacts, resolved);
+
+  const skillSync = syncSkills({
+    sourceDir: resolved.sourceDir,
+    localSkillsDir: resolved.localSkillsDir,
+    globalSkillsDir: resolved.globalSkillsDir,
+    global: resolved.includeGlobal,
+    dryRun: resolved.dryRun,
+    quiet: true,
+  });
+
+  await commandSync({
+    projectRoot: resolved.projectRoot,
+    ide: null,
+    dryRun: resolved.dryRun,
+    verbose: false,
+    quiet: true,
+  });
+
+  const localValidation = validateCodexSkills({
+    projectRoot: resolved.projectRoot,
+    sourceDir: resolved.sourceDir,
+    skillsDir: resolved.localSkillsDir,
+    strict: true,
+    quiet: true,
+  });
+
+  const globalValidation = resolved.includeGlobal
+    ? validateCodexSkills({
+      projectRoot: resolved.projectRoot,
+      sourceDir: resolved.sourceDir,
+      skillsDir: resolved.globalSkillsDir,
+      strict: true,
+      allowOrphaned: true,
+      quiet: true,
+    })
+    : null;
+
+  const geminiValidation = validateGeminiCommands(agents, resolved.geminiCommandsDir);
+
+  return {
+    ok: localValidation.ok && (globalValidation ? globalValidation.ok : true) && geminiValidation.ok,
+    agentsChecked: agents.length,
+    removed: cleanup.removed,
+    skipped: cleanup.skipped,
+    skillSync,
+    validations: {
+      localCodex: localValidation,
+      globalCodex: globalValidation,
+      gemini: geminiValidation,
+    },
+  };
+}
+
+function formatHumanReport(result) {
+  const lines = [
+    result.ok
+      ? `✅ Agent/skill reference repair completed (${result.agentsChecked} core agents checked)`
+      : `❌ Agent/skill reference repair found issues (${result.agentsChecked} core agents checked)`,
+    `- Removed legacy artifacts: ${result.removed.length}`,
+    `- Skipped missing legacy artifacts: ${result.skipped.length}`,
+    `- Local Codex validation: ${result.validations.localCodex.ok ? 'pass' : 'fail'}`,
+    `- Global Codex validation: ${result.validations.globalCodex ? (result.validations.globalCodex.ok ? 'pass' : 'fail') : 'skipped'}`,
+    `- Gemini validation: ${result.validations.gemini.ok ? 'pass' : 'fail'}`,
+  ];
+
+  const detailErrors = [
+    ...result.validations.localCodex.errors,
+    ...(result.validations.globalCodex ? result.validations.globalCodex.errors : []),
+    ...result.validations.gemini.errors,
+  ];
+
+  if (detailErrors.length > 0) {
+    lines.push(...detailErrors.map(error => `  • ${error}`));
+  }
+
+  return lines.join('\n');
+}
+
+async function main() {
+  const options = parseArgs();
+  const result = await repairAgentReferences(options);
+
+  if (!options.quiet) {
+    if (options.json) {
+      console.log(JSON.stringify(result, null, 2));
+    } else {
+      console.log(formatHumanReport(result));
+    }
+  }
+
+  if (!result.ok) {
+    process.exitCode = 1;
+  }
+}
+
+if (require.main === module) {
+  main().catch((error) => {
+    console.error(`❌ ${error.message}`);
+    process.exit(1);
+  });
+}
+
+module.exports = {
+  buildLegacyArtifacts,
+  removeLegacyArtifacts,
+  validateGeminiCommands,
+  repairAgentReferences,
+  parseArgs,
+  getDefaultOptions,
+  formatHumanReport,
+};

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

@@ -17,10 +17,28 @@ function countMarkdownFiles(dirPath) {
   return fs.readdirSync(dirPath).filter((f) => f.endsWith('.md')).length;
 }
 
+function listMarkdownBasenames(dirPath) {
+  if (!fs.existsSync(dirPath)) return [];
+  return fs.readdirSync(dirPath)
+    .filter((f) => f.endsWith('.md'))
+    .map((f) => path.basename(f, '.md'))
+    .sort();
+}
+
+function listClaudeAgentSkillIds(skillsAgentsDir) {
+  if (!fs.existsSync(skillsAgentsDir)) return [];
+  return fs.readdirSync(skillsAgentsDir, { withFileTypes: true })
+    .filter((entry) => entry.isDirectory() && fs.existsSync(path.join(skillsAgentsDir, entry.name, 'SKILL.md')))
+    .map((entry) => entry.name)
+    .sort();
+}
+
 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', 'AIOX', 'agents');
+  const skillsAgentsDir =
+    options.skillsAgentsDir || path.join(projectRoot, '.claude', 'skills', 'AIOX', 'agents');
   const hooksDir = options.hooksDir || path.join(projectRoot, '.claude', 'hooks');
   const sourceAgentsDir =
     options.sourceAgentsDir || path.join(projectRoot, '.aiox-core', 'development', 'agents');
@@ -29,7 +47,10 @@ function validateClaudeIntegration(options = {}) {
   const warnings = [];
 
   if (!fs.existsSync(agentsDir)) {
-    errors.push(`Missing Claude agents dir: ${path.relative(projectRoot, agentsDir)}`);
+    warnings.push(`Missing legacy Claude commands dir: ${path.relative(projectRoot, agentsDir)}`);
+  }
+  if (!fs.existsSync(skillsAgentsDir)) {
+    errors.push(`Missing Claude agent skills dir: ${path.relative(projectRoot, skillsAgentsDir)}`);
   }
   if (!fs.existsSync(rulesFile)) {
     warnings.push(`Claude rules file not found yet: ${path.relative(projectRoot, rulesFile)}`);
@@ -38,10 +59,36 @@ function validateClaudeIntegration(options = {}) {
     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})`);
+  const sourceAgents = listMarkdownBasenames(sourceAgentsDir);
+  const commandAgents = listMarkdownBasenames(agentsDir);
+  const skillAgents = listClaudeAgentSkillIds(skillsAgentsDir);
+
+  if (sourceAgents.length > 0 && skillAgents.length !== sourceAgents.length) {
+    errors.push(`Claude agent skill count differs from source (${skillAgents.length}/${sourceAgents.length})`);
+  }
+
+  for (const sourceAgent of sourceAgents) {
+    if (!skillAgents.includes(sourceAgent)) {
+      errors.push(`Missing Claude agent skill: ${sourceAgent}`);
+      continue;
+    }
+
+    const skillPath = path.join(skillsAgentsDir, sourceAgent, 'SKILL.md');
+    let skillContent = '';
+    try {
+      skillContent = fs.readFileSync(skillPath, 'utf8');
+    } catch (_error) {
+      errors.push(`Cannot read Claude agent skill: ${sourceAgent}`);
+      continue;
+    }
+
+    if (!skillContent.includes('activation_type: pipeline')) {
+      errors.push(`Claude agent skill missing activation_type: pipeline: ${sourceAgent}`);
+    }
+  }
+
+  if (sourceAgents.length > 0 && commandAgents.length !== sourceAgents.length) {
+    warnings.push(`Legacy Claude command count differs from source (${commandAgents.length}/${sourceAgents.length})`);
   }
 
   return {
@@ -49,15 +96,18 @@ function validateClaudeIntegration(options = {}) {
     errors,
     warnings,
     metrics: {
-      sourceAgents: sourceCount,
-      claudeAgents: claudeCount,
+      sourceAgents: sourceAgents.length,
+      claudeCommands: commandAgents.length,
+      claudeSkills: skillAgents.length,
     },
   };
 }
 
 function formatHumanReport(result) {
   if (result.ok) {
-    const lines = [`✅ Claude integration validation passed (agents: ${result.metrics.claudeAgents})`];
+    const lines = [
+      `✅ Claude integration validation passed (skills: ${result.metrics.claudeSkills}, legacy commands: ${result.metrics.claudeCommands})`,
+    ];
     if (result.warnings.length > 0) {
       lines.push(...result.warnings.map((w) => `⚠️ ${w}`));
     }
@@ -98,4 +148,6 @@ module.exports = {
   validateClaudeIntegration,
   parseArgs,
   countMarkdownFiles,
+  listMarkdownBasenames,
+  listClaudeAgentSkillIds,
 };

package/.aiox-core/infrastructure/scripts/validate-paths.js

@@ -9,6 +9,7 @@ const FORBIDDEN_ABSOLUTE_PATTERNS = [
   /\/home\/[^\s/'"]+/g,
   /[A-Za-z]:\\Users\\[^\s\\'"]+/g,
 ];
+const GENERATED_SKILL_MARKER = '<!-- AIOX-CODEX-LOCAL-SKILLS: generated -->';
 
 function getDefaultOptions() {
   const projectRoot = process.cwd();
@@ -56,6 +57,12 @@ function collectAbsolutePathViolations(content, filePath) {
 
 function validateSkillPathConventions(content, filePath) {
   const errors = [];
+  const generatedSquadSource = extractGeneratedSquadSource(content);
+
+  if (content.includes(GENERATED_SKILL_MARKER) && generatedSquadSource) {
+    return errors;
+  }
+
   if (!content.includes('.aiox-core/development/agents/')) {
     errors.push(`${filePath} missing canonical source path ".aiox-core/development/agents/"`);
   }
@@ -65,6 +72,11 @@ function validateSkillPathConventions(content, filePath) {
   return errors;
 }
 
+function extractGeneratedSquadSource(content) {
+  const match = String(content || '').match(/`(squads\/[^`]+\/agents\/[^`]+\.md)`/);
+  return match ? match[1] : '';
+}
+
 function validatePaths(options = {}) {
   const resolved = { ...getDefaultOptions(), ...options };
   const errors = [];
@@ -139,4 +151,5 @@ module.exports = {
   listSkillFiles,
   collectAbsolutePathViolations,
   validateSkillPathConventions,
+  extractGeneratedSquadSource,
 };