aiox-core 5.0.5 → 5.0.8

package/.aiox-core/infrastructure/scripts/codex-skills-sync/index.js

@@ -5,6 +5,8 @@ const fs = require('fs-extra');
 const path = require('path');
 const os = require('os');
 
+// summary: Sync local Codex skills for core AIOX agents.
+
 const {
   parseAllAgents,
   normalizeCommands,
@@ -43,6 +45,13 @@ function getSkillId(agentId) {
   return `aiox-${id}`;
 }
 
+function getLegacySkillId(agentId) {
+  const id = String(agentId || '').trim();
+  if (!id) return 'aios-unknown';
+  if (id.startsWith('aiox-')) return id.replace(/^aiox-/, 'aios-');
+  return `aios-${id}`;
+}
+
 function buildSkillContent(agentData) {
   const agent = agentData.agent || {};
   const name = agent.name || agentData.id;
@@ -179,4 +188,5 @@ module.exports = {
   parseArgs,
   getCodexHome,
   getSkillId,
+  getLegacySkillId,
 };

package/.aiox-core/infrastructure/scripts/codex-skills-sync/validate.js

@@ -5,7 +5,9 @@ const fs = require('fs');
 const path = require('path');
 
 const { parseAllAgents } = require('../ide-sync/agent-parser');
-const { getSkillId } = require('./index');
+const { getSkillId, getLegacySkillId } = require('./index');
+
+const GENERATED_MARKER = '<!-- AIOX-CODEX-LOCAL-SKILLS: generated -->';
 
 function getDefaultOptions() {
   const projectRoot = process.cwd();
@@ -14,6 +16,7 @@ function getDefaultOptions() {
     sourceDir: path.join(projectRoot, '.aiox-core', 'development', 'agents'),
     skillsDir: path.join(projectRoot, '.codex', 'skills'),
     strict: false,
+    allowOrphaned: false,
     quiet: false,
     json: false,
   };
@@ -59,6 +62,35 @@ function validateSkillContent(content, expected) {
   return issues;
 }
 
+function extractGeneratedSquadSource(content) {
+  const value = String(content || '');
+  const patterns = [
+    /`(squads\/[^`]+\/agents\/[^`]+\.md)`/,
+    /<!--\s*Source:\s*(squads\/[^>\s]+\/agents\/[^>\s]+\.md)\s*-->/,
+    /<!--\s*(squads\/[^>\s]+\/agents\/[^>\s]+\.md)\s*-->/,
+  ];
+
+  for (const pattern of patterns) {
+    const match = value.match(pattern);
+    if (match) return match[1];
+  }
+
+  return '';
+}
+
+function isGeneratedSquadSkill(content, projectRoot) {
+  if (!String(content || '').includes(GENERATED_MARKER)) {
+    return false;
+  }
+
+  const sourcePath = extractGeneratedSquadSource(content);
+  if (!sourcePath) {
+    return false;
+  }
+
+  return fs.existsSync(path.join(projectRoot, sourcePath));
+}
+
 function validateCodexSkills(options = {}) {
   const resolved = { ...getDefaultOptions(), ...options };
   const errors = [];
@@ -66,7 +98,7 @@ function validateCodexSkills(options = {}) {
 
   if (!fs.existsSync(resolved.skillsDir)) {
     errors.push(`Skills directory not found: ${resolved.skillsDir}`);
-    return { ok: false, checked: 0, expected: 0, errors, warnings, missing: [], orphaned: [] };
+    return { ok: false, checked: 0, expected: 0, errors, warnings, missing: [], orphaned: [], ignored: [] };
   }
 
   const agents = parseAllAgents(resolved.sourceDir).filter(isParsableAgent);
@@ -74,6 +106,7 @@ function validateCodexSkills(options = {}) {
     agentId: agent.id,
     filename: agent.filename,
     skillId: getSkillId(agent.id),
+    legacySkillId: getLegacySkillId(agent.id),
   }));
 
   const missing = [];
@@ -99,13 +132,37 @@ function validateCodexSkills(options = {}) {
   }
 
   const expectedIds = new Set(expected.map(item => item.skillId));
+  const legacyIds = new Set(expected.map(item => item.legacySkillId));
   const orphaned = [];
+  const legacy = [];
+  const ignored = [];
   if (resolved.strict) {
     const dirs = fs.readdirSync(resolved.skillsDir, { withFileTypes: true })
-      .filter(entry => entry.isDirectory() && entry.name.startsWith('aiox-'))
+      .filter(entry => entry.isDirectory() && (entry.name.startsWith('aiox-') || entry.name.startsWith('aios-')))
       .map(entry => entry.name);
     for (const dir of dirs) {
-      if (!expectedIds.has(dir)) {
+      if (legacyIds.has(dir)) {
+        legacy.push(dir);
+        errors.push(`Legacy skill alias directory: ${path.join(path.relative(resolved.projectRoot, resolved.skillsDir), dir)}`);
+        continue;
+      }
+      if (dir.startsWith('aiox-') && !expectedIds.has(dir)) {
+        if (resolved.allowOrphaned) {
+          continue;
+        }
+        const skillPath = path.join(resolved.skillsDir, dir, 'SKILL.md');
+        let content = '';
+        try {
+          content = fs.readFileSync(skillPath, 'utf8');
+        } catch (_error) {
+          content = '';
+        }
+
+        if (isGeneratedSquadSkill(content, resolved.projectRoot)) {
+          ignored.push(dir);
+          continue;
+        }
+
         orphaned.push(dir);
         errors.push(`Orphaned skill directory: ${path.join(path.relative(resolved.projectRoot, resolved.skillsDir), dir)}`);
       }
@@ -124,6 +181,8 @@ function validateCodexSkills(options = {}) {
     warnings,
     missing,
     orphaned,
+    legacy,
+    ignored,
   };
 }
 
@@ -167,6 +226,8 @@ if (require.main === module) {
 module.exports = {
   validateCodexSkills,
   validateSkillContent,
+  extractGeneratedSquadSource,
+  isGeneratedSquadSkill,
   parseArgs,
   getDefaultOptions,
 };

package/.aiox-core/infrastructure/scripts/generate-settings-json.js

@@ -243,11 +243,36 @@ function writeSettingsJson(projectRoot, permissions) {
   }
 
   const updated = { ...existing };
-
-  if (permissions.deny.length > 0 || permissions.allow.length > 0) {
-    updated.permissions = permissions;
+  const existingPermissions =
+    existing && existing.permissions && typeof existing.permissions === 'object'
+      ? existing.permissions
+      : {};
+  const generatedPermissionsEmpty =
+    permissions.allow.length === 0 && permissions.deny.length === 0;
+
+  if (generatedPermissionsEmpty) {
+    if (Object.keys(existingPermissions).length > 0) {
+      updated.permissions = existingPermissions;
+    } else {
+      delete updated.permissions;
+    }
   } else {
-    delete updated.permissions;
+    const mergedAllow = Array.from(
+      new Set([...(Array.isArray(existingPermissions.allow) ? existingPermissions.allow : []), ...permissions.allow]),
+    );
+    const mergedDeny = Array.from(
+      new Set([...(Array.isArray(existingPermissions.deny) ? existingPermissions.deny : []), ...permissions.deny]),
+    );
+
+    if (mergedDeny.length > 0 || mergedAllow.length > 0) {
+      updated.permissions = {
+        ...existingPermissions,
+        allow: mergedAllow,
+        deny: mergedDeny,
+      };
+    } else {
+      delete updated.permissions;
+    }
   }
 
   const newContent = JSON.stringify(updated, null, 2) + '\n';

package/.aiox-core/infrastructure/scripts/ide-sync/agent-parser.js

@@ -119,8 +119,12 @@ function extractAgentInfoFallback(content) {
  * @returns {object} - Parsed agent data
  */
 function parseAgentFile(filePath) {
+  const relativeSourcePath = path.relative(process.cwd(), filePath);
   const result = {
     path: filePath,
+    sourcePath: relativeSourcePath && !relativeSourcePath.startsWith('..') && !path.isAbsolute(relativeSourcePath)
+      ? relativeSourcePath.split(path.sep).join('/')
+      : null,
     filename: path.basename(filePath),
     id: path.basename(filePath, '.md'),
     raw: null,

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

@@ -60,6 +60,7 @@ function loadConfig(projectRoot) {
       'claude-code': {
         enabled: true,
         path: '.claude/commands/AIOX/agents',
+        skillsPath: '.claude/skills',
         format: 'full-markdown-yaml',
       },
       codex: {
@@ -133,6 +134,14 @@ function getTransformer(format) {
   return transformers[format] || claudeCodeTransformer;
 }
 
+function transformPrimaryContent(transformer, agent, ideName) {
+  if (ideName === 'claude-code' && typeof transformer.transformCommand === 'function') {
+    return transformer.transformCommand(agent);
+  }
+
+  return transformer.transform(agent);
+}
+
 /**
  * Sync agents to a specific IDE
  * @param {object[]} agents - Parsed agent data
@@ -146,7 +155,9 @@ function syncIde(agents, ideConfig, ideName, projectRoot, options) {
   const result = {
     ide: ideName,
     targetDir: path.join(projectRoot, ideConfig.path),
+    skillRootDir: ideConfig.skillsPath ? path.join(projectRoot, ideConfig.skillsPath) : null,
     files: [],
+    skillFiles: [],
     errors: [],
   };
 
@@ -181,7 +192,7 @@ function syncIde(agents, ideConfig, ideName, projectRoot, options) {
     }
 
     try {
-      const content = transformer.transform(agent);
+      const content = transformPrimaryContent(transformer, agent, ideName);
       const filename = transformer.getFilename(agent);
       const targetPath = path.join(result.targetDir, filename);
 
@@ -195,6 +206,25 @@ function syncIde(agents, ideConfig, ideName, projectRoot, options) {
         path: targetPath,
         content,
       });
+
+      if (ideName === 'claude-code' && typeof transformer.transformSkill === 'function') {
+        const skillContent = transformer.transformSkill(agent);
+        const skillRelativePath = transformer.getSkillRelativePath(agent);
+        const skillRootDir = result.skillRootDir || path.join(projectRoot, '.claude', 'skills');
+        const skillPath = path.join(skillRootDir, skillRelativePath);
+
+        if (!options.dryRun) {
+          fs.ensureDirSync(path.dirname(skillPath));
+          fs.writeFileSync(skillPath, skillContent, 'utf8');
+        }
+
+        result.skillFiles.push({
+          agent: agent.id,
+          filename: skillRelativePath,
+          path: skillPath,
+          content: skillContent,
+        });
+      }
     } catch (error) {
       result.errors.push({
         agent: agent.id,
@@ -211,7 +241,7 @@ function syncIde(agents, ideConfig, ideName, projectRoot, options) {
  * @param {object} options - Command options
  */
 async function commandSync(options) {
-  const projectRoot = process.cwd();
+  const projectRoot = options.projectRoot || process.cwd();
   const config = loadConfig(projectRoot);
 
   if (!config.enabled) {
@@ -284,6 +314,7 @@ async function commandSync(options) {
     }
 
     const agentCount = result.files.length;
+    const skillCount = (result.skillFiles || []).length;
     const commandCount = (result.commandFiles || []).length;
     const redirectCount = redirectResult.written.length;
     const errorCount = result.errors.length;
@@ -295,7 +326,7 @@ async function commandSync(options) {
       }
 
       console.log(
-        `   ${status} ${agentCount} agents${commandCount > 0 ? `, ${commandCount} commands` : ''}, ${redirectCount} redirects${errorCount > 0 ? `, ${errorCount} errors` : ''}`
+        `   ${status} ${agentCount} agents${skillCount > 0 ? `, ${skillCount} skills` : ''}${commandCount > 0 ? `, ${commandCount} commands` : ''}, ${redirectCount} redirects${errorCount > 0 ? `, ${errorCount} errors` : ''}`
       );
 
       if (options.verbose && result.errors.length > 0) {
@@ -307,7 +338,10 @@ async function commandSync(options) {
   }
 
   // Summary
-  const totalFiles = results.reduce((sum, r) => sum + r.files.length + (r.commandFiles || []).length, 0);
+  const totalFiles = results.reduce(
+    (sum, r) => sum + r.files.length + (r.skillFiles || []).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);
@@ -317,11 +351,11 @@ async function commandSync(options) {
 
     if (options.dryRun) {
       console.log(
-        `${colors.yellow}Dry run: ${totalFiles} agents + ${totalRedirects} redirects would be written${colors.reset}`
+        `${colors.yellow}Dry run: ${totalFiles} files + ${totalRedirects} redirects would be written${colors.reset}`
       );
     } else {
       console.log(
-        `${colors.green}✅ Sync complete: ${totalFiles} agents + ${totalRedirects} redirects${colors.reset}`
+        `${colors.green}✅ Sync complete: ${totalFiles} files + ${totalRedirects} redirects${colors.reset}`
       );
     }
 
@@ -373,7 +407,7 @@ async function commandValidate(options) {
       if (agent.error) continue;
 
       try {
-        const content = transformer.transform(agent);
+        const content = transformPrimaryContent(transformer, agent, ideName);
         const filename = transformer.getFilename(agent);
         expectedFiles.push({ filename, content });
       } catch (error) {
@@ -411,6 +445,31 @@ async function commandValidate(options) {
         targetDir: path.join(projectRoot, '.gemini', 'commands'),
       };
     }
+
+    if (ideName === 'claude-code' && typeof transformer.transformSkill === 'function') {
+      const skillNamespace = path.posix.join('AIOX', 'agents') + '/';
+      const expectedSkillFiles = [];
+
+      for (const agent of agents) {
+        if (agent.error) continue;
+
+        try {
+          const skillContent = transformer.transformSkill(agent);
+          const skillRelativePath = transformer.getSkillRelativePath(agent);
+          const filename = skillRelativePath.startsWith(skillNamespace)
+            ? skillRelativePath.slice(skillNamespace.length)
+            : skillRelativePath;
+          expectedSkillFiles.push({ filename, content: skillContent });
+        } catch (error) {
+          // Skip agents that fail to transform
+        }
+      }
+
+      ideConfigs['claude-code-skills'] = {
+        expectedFiles: expectedSkillFiles,
+        targetDir: path.join(projectRoot, ideConfig.skillsPath || '.claude/skills', 'AIOX', 'agents'),
+      };
+    }
   }
 
   // Validate
@@ -534,6 +593,7 @@ if (require.main === module) {
 module.exports = {
   loadConfig,
   getTransformer,
+  transformPrimaryContent,
   syncIde,
   commandSync,
   commandValidate,

package/.aiox-core/infrastructure/scripts/ide-sync/transformers/claude-code.js

@@ -6,6 +6,27 @@
  * Target: .claude/commands/AIOX/agents/*.md
  */
 
+const path = require('path');
+
+function normalizePath(value) {
+  return String(value || '').split(path.sep).join('/');
+}
+
+function getSourcePath(agentData) {
+  if (agentData.sourcePath) {
+    return normalizePath(agentData.sourcePath);
+  }
+
+  if (agentData.path) {
+    const relative = path.relative(process.cwd(), agentData.path);
+    if (relative && !relative.startsWith('..') && !path.isAbsolute(relative)) {
+      return normalizePath(relative);
+    }
+  }
+
+  return `.aiox-core/development/agents/${agentData.filename}`;
+}
+
 /**
  * Transform agent data to Claude Code format
  * For Claude Code, we use the full original file (identity transform)
@@ -13,12 +34,13 @@
  * @returns {string} - Transformed content
  */
 function transform(agentData) {
+  const sourcePath = getSourcePath(agentData);
   // Claude Code uses the full original file
   if (agentData.raw) {
     // Add sync footer if not present
-    const syncFooter = `\n---\n*AIOX Agent - Synced from .aiox-core/development/agents/${agentData.filename}*\n`;
+    const syncFooter = `\n---\n*AIOX Agent - Synced from ${sourcePath}*\n`;
 
-    if (!agentData.raw.includes('Synced from .aiox-core/development/agents/')) {
+    if (!agentData.raw.includes(`Synced from ${sourcePath}`)) {
       return agentData.raw.trimEnd() + syncFooter;
     }
     return agentData.raw;
@@ -28,6 +50,47 @@ function transform(agentData) {
   return generateMinimalContent(agentData);
 }
 
+/**
+ * Transform agent data to a Claude Code legacy command shim.
+ * The full activation payload lives in the Claude Skill sidecar.
+ * @param {object} agentData - Parsed agent data from agent-parser
+ * @returns {string} - Legacy command shim content
+ */
+function transformCommand(agentData) {
+  const agent = agentData.agent || {};
+  const sourcePath = getSourcePath(agentData);
+  const skillPath = `.claude/skills/${getSkillRelativePath(agentData)}`;
+  const name = agent.name || agentData.id;
+  const title = agent.title || 'AIOX Agent';
+  const whenToUse = normalizeInlineText(
+    agent.whenToUse || 'Use this AIOX agent when the task matches its responsibility.',
+    360
+  );
+
+  return `# ${agentData.id}
+
+<!-- ACORE-CLAUDE-AGENT-COMMAND: legacy-shim -->
+<!-- Canonical Skill: ${skillPath} -->
+<!-- Source: ${sourcePath} -->
+
+**${name}** - ${title}
+
+> ${whenToUse}
+
+## Compatibility Activation
+
+This command is a legacy compatibility shim. The canonical Claude activation payload is:
+
+\`${skillPath}\`
+
+When this command is invoked:
+
+1. Read \`${skillPath}\` in full.
+2. Follow the activation instructions from that skill.
+3. If the skill file is unavailable, read \`${sourcePath}\` as fallback.
+`;
+}
+
 /**
  * Generate minimal content if raw file is unavailable
  * @param {object} agentData - Parsed agent data
@@ -36,6 +99,7 @@ function transform(agentData) {
 function generateMinimalContent(agentData) {
   const agent = agentData.agent || {};
   const persona = agentData.persona_profile || {};
+  const sourcePath = getSourcePath(agentData);
 
   const icon = agent.icon || '🤖';
   const name = agent.name || agentData.id;
@@ -62,12 +126,86 @@ ${icon} **${name}** - ${title}
 
   content += `
 ---
-*AIOX Agent - Synced from .aiox-core/development/agents/${agentData.filename}*
+*AIOX Agent - Synced from ${sourcePath}*
 `;
 
   return content;
 }
 
+/**
+ * Normalize free text for YAML frontmatter.
+ * @param {string} text - Raw text
+ * @param {number} maxLength - Maximum length
+ * @returns {string} - Normalized text
+ */
+function normalizeInlineText(text, maxLength = 240) {
+  const value = String(text || '').replace(/\s+/g, ' ').trim();
+
+  if (value.length <= maxLength) {
+    return value;
+  }
+
+  return `${value.slice(0, maxLength - 3).trimEnd()}...`;
+}
+
+/**
+ * Quote a value for one-line YAML frontmatter.
+ * @param {string} value - Raw value
+ * @returns {string} - YAML-safe quoted value
+ */
+function quoteYamlString(value) {
+  return JSON.stringify(normalizeInlineText(value));
+}
+
+/**
+ * Build a Claude skill description from the parsed agent metadata.
+ * @param {object} agentData - Parsed agent data
+ * @returns {string} - Skill description
+ */
+function buildSkillDescription(agentData) {
+  const agent = agentData.agent || {};
+  const name = agent.name || agentData.id;
+  const title = agent.title || 'AIOX Agent';
+  const whenToUse = agent.whenToUse || 'Use this AIOX agent when the task matches its responsibility.';
+
+  return `Activate ${name} (${agentData.id}) for ${title}. ${whenToUse}`;
+}
+
+/**
+ * Get the relative Claude skill path for this agent under .claude/skills.
+ * @param {object} agentData - Parsed agent data
+ * @returns {string} - Relative skill path
+ */
+function getSkillRelativePath(agentData) {
+  return path.posix.join('AIOX', 'agents', agentData.id, 'SKILL.md');
+}
+
+/**
+ * Transform agent data to a Claude Skill sidecar.
+ * The command file remains the compatibility surface; the skill is the new canonical Claude surface.
+ * @param {object} agentData - Parsed agent data from agent-parser
+ * @returns {string} - Skill content
+ */
+function transformSkill(agentData) {
+  const sourcePath = getSourcePath(agentData);
+  const name = `aiox-${agentData.id}`;
+  const description = buildSkillDescription(agentData);
+  const sourceContent = agentData.raw ? agentData.raw.trimEnd() : generateMinimalContent(agentData).trimEnd();
+
+  return `---
+name: ${name}
+description: ${quoteYamlString(description)}
+user-invocable: true
+activation_type: pipeline
+---
+
+<!-- ACORE-CLAUDE-AGENT-SKILL: generated -->
+<!-- Source: ${sourcePath} -->
+
+${sourceContent}
+`;
+}
+
 /**
  * Get the target filename for this agent
  * @param {object} agentData - Parsed agent data
@@ -79,6 +217,10 @@ function getFilename(agentData) {
 
 module.exports = {
   transform,
+  transformCommand,
+  transformSkill,
   getFilename,
+  getSkillRelativePath,
+  getSourcePath,
   format: 'full-markdown-yaml',
 };