ma-agents 2.16.0 → 2.16.1

package/lib/installer.js

@@ -5,7 +5,7 @@ const prompts = require('prompts');
 const { getAgent, getAllAgents } = require('./agents');
 
 const MANIFEST_FILE = '.ma-agents.json';
-const MANIFEST_VERSION = '1.0.0';
+const MANIFEST_VERSION = '1.1.0';
 
 function getPackageVersion() {
   const pkg = JSON.parse(fs.readFileSync(path.join(__dirname, '..', 'package.json'), 'utf-8'));
@@ -37,13 +37,33 @@ function ensureManifest(installPath, agentId, scope) {
     manifest = {
       manifestVersion: MANIFEST_VERSION,
       agent: agentId,
+      agents: [agentId],
       scope: scope,
       skills: {}
     };
+  } else {
+    // Migrate v1.0.0 manifests: add agents array if missing
+    if (!manifest.agents) {
+      manifest.agents = manifest.agent ? [manifest.agent] : [];
+    }
+    // Add current agent if not already present
+    if (agentId && !manifest.agents.includes(agentId)) {
+      manifest.agents.push(agentId);
+    }
+    // Keep backward-compat agent field as first agent
+    manifest.agent = manifest.agents[0] || null;
   }
   return manifest;
 }
 
+function getManifestAgents(manifest) {
+  if (!manifest) return [];
+  if (manifest.agents && Array.isArray(manifest.agents)) {
+    return manifest.agents;
+  }
+  return manifest.agent ? [manifest.agent] : [];
+}
+
 function getInstalledSkillInfo(installPath, skillId) {
   const manifest = readManifest(installPath);
   if (!manifest || !manifest.skills || !manifest.skills[skillId]) {
@@ -52,13 +72,13 @@ function getInstalledSkillInfo(installPath, skillId) {
   return manifest.skills[skillId];
 }
 
-async function generateSkillsManifest(installPath, agent) {
+async function generateSkillsManifest(installPath) {
   const skills = listSkills();
   const manifest = readManifest(installPath);
   if (!manifest || !manifest.skills) return;
 
   const manifestYamlPath = path.join(installPath, 'MANIFEST.yaml');
-  let yamlContent = '# skills/MANIFEST.yaml\n\nskills:\n';
+  let yamlContent = '# MANIFEST.yaml\n\nskills:\n';
 
   const skillIds = Object.keys(manifest.skills).sort();
   for (const skillId of skillIds) {
@@ -66,7 +86,7 @@ async function generateSkillsManifest(installPath, agent) {
     if (!skill) continue;
 
     yamlContent += `  - id: ${skillId}\n`;
-    yamlContent += `    file: skills/${skillId}/SKILL.md\n`;
+    yamlContent += `    file: ${skillId}/SKILL.md\n`;
     yamlContent += `    description: ${skill.description}\n`;
 
     if (skill.applies_when && Array.isArray(skill.applies_when)) {
@@ -91,7 +111,7 @@ async function updateAgentInstructions(agent, projectRoot) {
   if (!agent.instructionFiles || agent.instructionFiles.length === 0) return;
 
   const agentProjectPath = agent.getProjectPath();
-  const relManifestPath = path.relative(process.cwd(), path.join(agentProjectPath, 'MANIFEST.yaml')).replace(/\\/g, '/');
+  const relManifestPath = path.relative(projectRoot, path.join(agentProjectPath, 'MANIFEST.yaml')).replace(/\\/g, '/');
 
   const planningInstruction = `
 # AI Agent Skills - Planning Instruction
@@ -259,16 +279,26 @@ async function installSkill(skillId, agentIds, customPath = '', scope = 'project
 
   console.log(chalk.cyan(`\nInstalling skill: ${skill.name} v${skill.version}`));
 
+  // Group agents by their resolved install path to avoid redundant installs
+  const pathGroups = new Map();
   for (const agentId of agentIds) {
     const agent = getAgent(agentId);
-
     if (!agent) {
       console.log(chalk.yellow(`  Warning: Skipping unknown agent: ${agentId}`));
       continue;
     }
+    const installPath = customPath || (scope === 'global' ? agent.getGlobalPath() : agent.getProjectPath());
+    if (!pathGroups.has(installPath)) {
+      pathGroups.set(installPath, []);
+    }
+    pathGroups.get(installPath).push({ agentId, agent });
+  }
+
+  for (const [installPath, agentEntries] of pathGroups) {
+    const primaryAgent = agentEntries[0].agent;
+    const agentNames = agentEntries.map(e => e.agent.name).join(', ');
 
     try {
-      const installPath = customPath || (scope === 'global' ? agent.getGlobalPath() : agent.getProjectPath());
       await fs.ensureDir(installPath);
 
       const installed = getInstalledSkillInfo(installPath, skillId);
@@ -284,7 +314,7 @@ async function installSkill(skillId, agentIds, customPath = '', scope = 'project
           action = batchState.globalAction;
         } else if (cmp > 0) {
           // Upgrade available
-          console.log(chalk.yellow(`  ${skill.name} v${installed.version} → v${skill.version} update available for ${agent.name}`));
+          console.log(chalk.yellow(`  ${skill.name} v${installed.version} → v${skill.version} update available for ${agentNames}`));
           const { choice } = await prompts({
             type: 'select',
             name: 'choice',
@@ -301,7 +331,7 @@ async function installSkill(skillId, agentIds, customPath = '', scope = 'project
           action = choice;
         } else if (cmp === 0) {
           // Same version
-          console.log(chalk.gray(`  ${skill.name} v${installed.version} already installed for ${agent.name}`));
+          console.log(chalk.gray(`  ${skill.name} v${installed.version} already installed for ${agentNames}`));
           const { choice } = await prompts({
             type: 'select',
             name: 'choice',
@@ -316,7 +346,7 @@ async function installSkill(skillId, agentIds, customPath = '', scope = 'project
           action = choice;
         } else {
           // Downgrade
-          console.log(chalk.yellow(`  ${skill.name} v${installed.version} installed, package has v${skill.version} for ${agent.name}`));
+          console.log(chalk.yellow(`  ${skill.name} v${installed.version} installed, package has v${skill.version} for ${agentNames}`));
           const { choice } = await prompts({
             type: 'select',
             name: 'choice',
@@ -353,15 +383,17 @@ async function installSkill(skillId, agentIds, customPath = '', scope = 'project
 
         if (action === 'remove') {
           await performUninstall(skillId, installPath);
-          const manifest = ensureManifest(installPath, agentId, scope);
+          const manifest = ensureManifest(installPath, agentEntries[0].agentId, scope);
           delete manifest.skills[skillId];
           writeManifest(installPath, manifest);
-          console.log(chalk.green(`    - Removed ${skill.name} from ${agent.name}`));
+          console.log(chalk.green(`    - Removed ${skill.name} from ${agentNames}`));
 
           // Generate MANIFEST.yaml and update agent instruction files
-          await generateSkillsManifest(installPath, agent);
+          await generateSkillsManifest(installPath);
           if (scope === 'project') {
-            await updateAgentInstructions(agent, process.cwd());
+            for (const entry of agentEntries) {
+              await updateAgentInstructions(entry.agent, process.cwd());
+            }
           }
           continue;
         }
@@ -374,14 +406,22 @@ async function installSkill(skillId, agentIds, customPath = '', scope = 'project
       }
 
       if (!installed || force) {
-        console.log(chalk.gray(`  Installing for ${agent.name}...`));
+        console.log(chalk.gray(`  Installing for ${agentNames}...`));
       }
 
-      const success = await performInstall(skillId, skill, agent, installPath);
+      // Perform the install ONCE for this shared path
+      const success = await performInstall(skillId, skill, primaryAgent, installPath);
 
       if (success) {
-        // Update manifest
-        const manifest = ensureManifest(installPath, agentId, scope);
+        // Update manifest with ALL agents that share this path
+        const manifest = ensureManifest(installPath, agentEntries[0].agentId, scope);
+        for (const entry of agentEntries) {
+          if (!manifest.agents.includes(entry.agentId)) {
+            manifest.agents.push(entry.agentId);
+          }
+        }
+        manifest.agent = manifest.agents[0];
+
         const now = new Date().toISOString();
         const existing = manifest.skills[skillId];
         manifest.skills[skillId] = {
@@ -389,14 +429,16 @@ async function installSkill(skillId, agentIds, customPath = '', scope = 'project
           installedAt: existing ? existing.installedAt : now,
           updatedAt: now,
           installerVersion: getPackageVersion(),
-          agentVersion: agent.version
+          agentVersion: primaryAgent.version
         };
         writeManifest(installPath, manifest);
 
-        // Generate MANIFEST.yaml and update agent instruction files
-        await generateSkillsManifest(installPath, agent);
+        // Generate MANIFEST.yaml and update instruction files for ALL agents
+        await generateSkillsManifest(installPath);
         if (scope === 'project') {
-          await updateAgentInstructions(agent, process.cwd());
+          for (const entry of agentEntries) {
+            await updateAgentInstructions(entry.agent, process.cwd());
+          }
         }
       }
     } catch (error) {
@@ -417,41 +459,65 @@ async function performUninstall(skillId, installPath) {
 async function uninstallSkill(skillId, agentIds, customPath = '', scope = 'project') {
   console.log(chalk.cyan(`\nUninstalling skill: ${skillId}`));
 
+  // Group agents by their resolved install path
+  const pathGroups = new Map();
   for (const agentId of agentIds) {
     const agent = getAgent(agentId);
-
     if (!agent) {
       console.log(chalk.yellow(`  Warning: Skipping unknown agent: ${agentId}`));
       continue;
     }
+    const installPath = customPath || (scope === 'global' ? agent.getGlobalPath() : agent.getProjectPath());
+    if (!pathGroups.has(installPath)) {
+      pathGroups.set(installPath, []);
+    }
+    pathGroups.get(installPath).push({ agentId, agent });
+  }
 
+  for (const [installPath, agentEntries] of pathGroups) {
     try {
-      const installPath = customPath || (scope === 'global' ? agent.getGlobalPath() : agent.getProjectPath());
       const installed = getInstalledSkillInfo(installPath, skillId);
 
       if (!installed) {
         const skillDir = path.join(installPath, skillId);
         if (fs.existsSync(skillDir)) {
           await performUninstall(skillId, installPath);
-          console.log(chalk.green(`  - Removed ${skillId} from ${agent.name} (legacy install)`));
+          console.log(chalk.green(`  - Removed ${skillId} from ${installPath} (legacy install)`));
         } else {
-          console.log(chalk.gray(`  ${skillId} is not installed for ${agent.name}`));
+          console.log(chalk.gray(`  ${skillId} is not installed at ${installPath}`));
         }
         continue;
       }
 
-      await performUninstall(skillId, installPath);
+      // Read current manifest to check which agents still need this path
+      const manifest = readManifest(installPath) || { agents: [], skills: {} };
+      const currentAgents = getManifestAgents(manifest);
 
-      const manifest = ensureManifest(installPath, agentId, scope);
-      delete manifest.skills[skillId];
-      writeManifest(installPath, manifest);
+      // Remove the requested agents from the manifest's agent list
+      const agentIdsToRemove = new Set(agentEntries.map(e => e.agentId));
+      const remainingAgents = currentAgents.filter(id => !agentIdsToRemove.has(id));
+
+      if (remainingAgents.length === 0) {
+        // No agents left that need this skill at this path -> delete the files
+        await performUninstall(skillId, installPath);
+        delete manifest.skills[skillId];
+        console.log(chalk.green(`  - Removed ${skillId} v${installed.version} from ${installPath}`));
+      } else {
+        // Other agents still need the files, just update the manifest
+        console.log(chalk.gray(`  ${skillId} still needed by ${remainingAgents.join(', ')} at ${installPath}, keeping files`));
+      }
 
-      console.log(chalk.green(`  - Removed ${skillId} v${installed.version} from ${agent.name}`));
+      // Update the agents list in manifest
+      manifest.agents = remainingAgents;
+      manifest.agent = remainingAgents[0] || null;
+      writeManifest(installPath, manifest);
 
-      // Generate MANIFEST.yaml and update agent instruction files
-      await generateSkillsManifest(installPath, agent);
+      // Regenerate MANIFEST.yaml and update instruction files
+      await generateSkillsManifest(installPath);
       if (scope === 'project') {
-        await updateAgentInstructions(agent, process.cwd());
+        for (const entry of agentEntries) {
+          await updateAgentInstructions(entry.agent, process.cwd());
+        }
       }
     } catch (error) {
       console.log(chalk.red(`    x Failed: ${error.message}`));
@@ -472,13 +538,20 @@ function getStatus(agentIds, customPath = '', scope = 'project') {
     const projectPath = agent.getProjectPath();
     const globalPath = agent.getGlobalPath();
 
-    // Check both scopes unless custom path is specified
-    const pathsToCheck = customPath
-      ? [{ path: customPath, scope: 'custom' }]
-      : [
+    // Filter paths based on scope
+    let pathsToCheck;
+    if (customPath) {
+      pathsToCheck = [{ path: customPath, scope: 'custom' }];
+    } else if (scope === 'global') {
+      pathsToCheck = [{ path: globalPath, scope: 'global' }];
+    } else if (scope === 'project') {
+      pathsToCheck = [{ path: projectPath, scope: 'project' }];
+    } else {
+      pathsToCheck = [
         { path: projectPath, scope: 'project' },
         { path: globalPath, scope: 'global' }
       ];
+    }
 
     for (const { path: checkPath, scope: checkScope } of pathsToCheck) {
       const manifest = readManifest(checkPath);
@@ -506,5 +579,6 @@ module.exports = {
   getStatus,
   readManifest,
   getInstalledSkillInfo,
+  getManifestAgents,
   compareSemver
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ma-agents",
-  "version": "2.16.0",
+  "version": "2.16.1",
   "description": "NPX tool to install skills for AI coding agents (Claude Code, Gemini, Copilot, Kilocode, Cline, Cursor)",
   "main": "index.js",
   "bin": {
@@ -30,6 +30,6 @@
     "fs-extra": "^11.1.1"
   },
   "engines": {
-    "node": ">=14.0.0"
+    "node": ">=16.0.0"
   }
-}
+}