feat(cli): support targeted global skill install with env prompt

Author: codeaholicguy

packages/cli/src/__tests__/lib/EnvironmentSelector.test.ts

@@ -220,4 +220,38 @@ describe('EnvironmentSelector', () => {
       expect(choices).toHaveLength(2);
     });
   });
+
+  describe('selectGlobalSkillEnvironments', () => {
+    it('should create choices from global-skill-capable environments', async () => {
+      mockPrompt.mockResolvedValue({ environments: ['claude'] });
+
+      await selector.selectGlobalSkillEnvironments();
+
+      expect(mockPrompt).toHaveBeenCalledWith([
+        expect.objectContaining({
+          type: 'checkbox',
+          name: 'environments',
+          message: 'Select AI environments for global skill installation (use space to select, enter to confirm):',
+          choices: expect.arrayContaining([
+            expect.objectContaining({ value: 'cursor' }),
+            expect.objectContaining({ value: 'claude' }),
+            expect.objectContaining({ value: 'codex' }),
+            expect.objectContaining({ value: 'gemini' }),
+            expect.objectContaining({ value: 'opencode' }),
+            expect.objectContaining({ value: 'antigravity' })
+          ]),
+          validate: expect.any(Function)
+        })
+      ]);
+    });
+
+    it('should return selected global-skill environments', async () => {
+      const selectedEnvs = ['claude', 'codex'];
+      mockPrompt.mockResolvedValue({ environments: selectedEnvs });
+
+      const result = await selector.selectGlobalSkillEnvironments();
+
+      expect(result).toEqual(selectedEnvs);
+    });
+  });
 });

packages/cli/src/__tests__/lib/SkillManager.test.ts

@@ -121,6 +121,10 @@ describe("SkillManager", () => {
       mockConfigManager.read.mockResolvedValue({
         environments: ["cursor", "claude"],
       } as any);
+      mockEnvironmentSelector.selectGlobalSkillEnvironments.mockResolvedValue([
+        "cursor",
+        "claude",
+      ]);
     });
 
     it("should successfully add a skill", async () => {
@@ -139,6 +143,61 @@ describe("SkillManager", () => {
       });
     });
 
+    it("should install to home directory when global option is enabled", async () => {
+      (mockedFs.pathExists as any).mockImplementation((checkPath: string) => {
+        if (
+          checkPath === path.join(os.homedir(), ".cursor", "skills", mockSkillName)
+          || checkPath === path.join(os.homedir(), ".claude", "skills", mockSkillName)
+        ) {
+          return Promise.resolve(false);
+        }
+        return Promise.resolve(true);
+      });
+
+      await skillManager.addSkill(mockRegistryId, mockSkillName, { global: true });
+
+      expect(mockedFs.symlink).toHaveBeenCalledWith(
+        expect.any(String),
+        path.join(os.homedir(), ".cursor", "skills", mockSkillName),
+        "dir",
+      );
+      expect(mockEnvironmentSelector.selectGlobalSkillEnvironments).toHaveBeenCalled();
+      expect(mockConfigManager.read).not.toHaveBeenCalled();
+      expect(mockConfigManager.create).not.toHaveBeenCalled();
+      expect(mockConfigManager.addSkill).not.toHaveBeenCalled();
+    });
+
+    it("should throw error when global env does not support skills", async () => {
+      await expect(
+        skillManager.addSkill(mockRegistryId, mockSkillName, { global: true, environments: ["windsurf"] }),
+      ).rejects.toThrow("Global skill installation is not supported for: windsurf");
+    });
+
+    it("should throw error when env is provided without global option", async () => {
+      await expect(
+        skillManager.addSkill(mockRegistryId, mockSkillName, { environments: ["claude"] }),
+      ).rejects.toThrow("--env can only be used with --global");
+    });
+
+    it("should install only selected global environments", async () => {
+      (mockedFs.pathExists as any).mockImplementation((checkPath: string) => {
+        if (checkPath === path.join(os.homedir(), ".claude", "skills", mockSkillName)) {
+          return Promise.resolve(false);
+        }
+        return Promise.resolve(true);
+      });
+
+      await skillManager.addSkill(mockRegistryId, mockSkillName, { global: true, environments: ["claude"] });
+
+      expect(mockedFs.symlink).toHaveBeenCalledTimes(1);
+      expect(mockedFs.symlink).toHaveBeenCalledWith(
+        expect.any(String),
+        path.join(os.homedir(), ".claude", "skills", mockSkillName),
+        "dir",
+      );
+      expect(mockEnvironmentSelector.selectGlobalSkillEnvironments).not.toHaveBeenCalled();
+    });
+
     it("should fetch registry using fetch API", async () => {
       const originalFetch = global.fetch;
       global.fetch = jest.fn().mockResolvedValue({
@@ -431,6 +490,23 @@ describe("SkillManager", () => {
       });
     });
 
+    it("should select environments when config exists but has no environments", async () => {
+      mockConfigManager.read.mockResolvedValue({
+        environments: [],
+      } as any);
+      mockEnvironmentSelector.selectSkillEnvironments.mockResolvedValue([
+        "claude",
+      ]);
+
+      await skillManager.addSkill(mockRegistryId, mockSkillName);
+
+      expect(mockConfigManager.create).not.toHaveBeenCalled();
+      expect(mockEnvironmentSelector.selectSkillEnvironments).toHaveBeenCalled();
+      expect(mockConfigManager.update).toHaveBeenCalledWith({
+        environments: ["claude"],
+      });
+    });
+
     it("should throw error if no skill-capable environments configured", async () => {
       mockConfigManager.read.mockResolvedValue({
         environments: ["windsurf", "gemini"],

packages/cli/src/__tests__/util/env.test.ts

@@ -11,6 +11,7 @@ import {
   getGlobalCapableEnvironments,
   hasGlobalSupport,
   getSkillPath,
+  getGlobalSkillPath,
   getSkillCapableEnvironments
 } from '../../util/env';
 import { EnvironmentCode } from '../../types';
@@ -39,7 +40,8 @@ describe('Environment Utilities', () => {
         name: 'Cursor',
         contextFileName: 'AGENTS.md',
         commandPath: '.cursor/commands',
-        skillPath: '.cursor/skills'
+        skillPath: '.cursor/skills',
+        globalSkillPath: '.cursor/skills'
       });
     });
 
@@ -300,6 +302,25 @@ describe('Environment Utilities', () => {
     });
   });
 
+  describe('getGlobalSkillPath', () => {
+    it('should return global skill path for cursor', () => {
+      expect(getGlobalSkillPath('cursor')).toBe('.cursor/skills');
+    });
+
+    it('should return global skill path for codex', () => {
+      expect(getGlobalSkillPath('codex')).toBe('.codex/skills');
+    });
+
+    it('should return global skill path for gemini', () => {
+      expect(getGlobalSkillPath('gemini')).toBe('.gemini/skills');
+    });
+
+    it('should return undefined for environments without global skill support', () => {
+      expect(getGlobalSkillPath('windsurf')).toBeUndefined();
+      expect(getGlobalSkillPath('github')).toBeUndefined();
+    });
+  });
+
   describe('getSkillCapableEnvironments', () => {
     it('should return only environments with skillPath defined', () => {
       const skillEnvs = getSkillCapableEnvironments();
@@ -353,4 +374,5 @@ describe('Environment Utilities', () => {
       expect(skillEnvs).toHaveLength(5);
     });
   });
+
 });

packages/cli/src/commands/skill.ts

@@ -13,12 +13,17 @@ export function registerSkillCommand(program: Command): void {
   skillCommand
     .command('add <registry-repo> <skill-name>')
     .description('Install a skill from a registry (e.g., ai-devkit skill add anthropics/skills frontend-design)')
-    .action(async (registryRepo: string, skillName: string) => {
+    .option('-g, --global', 'Install skill into configured global skill paths (~/<path>)')
+    .option('-e, --env <environment...>', 'Target environment(s) for global install (e.g., --global --env claude)')
+    .action(async (registryRepo: string, skillName: string, options: { global?: boolean; env?: string[] }) => {
       try {
         const configManager = new ConfigManager();
         const skillManager = new SkillManager(configManager);
 
-        await skillManager.addSkill(registryRepo, skillName);
+        await skillManager.addSkill(registryRepo, skillName, {
+          global: options.global,
+          environments: options.env,
+        });
       } catch (error: any) {
         ui.error(`Failed to add skill: ${error.message}`);
         process.exit(1);

packages/cli/src/lib/EnvironmentSelector.ts

@@ -1,5 +1,5 @@
 import inquirer from "inquirer";
-import { EnvironmentCode } from "../types";
+import { EnvironmentCode, EnvironmentDefinition } from "../types";
 import {
   getAllEnvironments,
   getEnvironmentDisplayName,
@@ -8,8 +8,15 @@ import {
 } from "../util/env";
 
 export class EnvironmentSelector {
-  async selectEnvironments(): Promise<EnvironmentCode[]> {
-    const environments = getAllEnvironments();
+  private async selectFromEnvironments(
+    environments: EnvironmentDefinition[],
+    message: string,
+    emptyMessage: string
+  ): Promise<EnvironmentCode[]> {
+    if (environments.length === 0) {
+      console.log(emptyMessage);
+      return [];
+    }
 
     const choices = environments.map((env) => ({
       name: env.name,
@@ -21,8 +28,7 @@ export class EnvironmentSelector {
       {
         type: "checkbox",
         name: "environments",
-        message:
-          "Select AI environments to set up (use space to select, enter to confirm):",
+        message,
         choices,
         pageSize: 10,
         validate: (input: EnvironmentCode[]) => {
@@ -37,6 +43,14 @@ export class EnvironmentSelector {
     return answers.environments;
   }
 
+  async selectEnvironments(): Promise<EnvironmentCode[]> {
+    return this.selectFromEnvironments(
+      getAllEnvironments(),
+      "Select AI environments to set up (use space to select, enter to confirm):",
+      "No environments available."
+    );
+  }
+
   async confirmOverride(conflicts: EnvironmentCode[]): Promise<boolean> {
     if (conflicts.length === 0) {
       return true;
@@ -70,70 +84,26 @@ export class EnvironmentSelector {
   }
 
   async selectGlobalEnvironments(): Promise<EnvironmentCode[]> {
-    const globalCapableEnvs = getGlobalCapableEnvironments();
-
-    if (globalCapableEnvs.length === 0) {
-      console.log("No environments support global setup.");
-      return [];
-    }
-
-    const choices = globalCapableEnvs.map((env) => ({
-      name: env.name,
-      value: env.code as EnvironmentCode,
-      short: env.name,
-    }));
-
-    const answers = await inquirer.prompt([
-      {
-        type: "checkbox",
-        name: "environments",
-        message:
-          "Select AI environments for global setup (use space to select, enter to confirm):",
-        choices,
-        pageSize: 10,
-        validate: (input: EnvironmentCode[]) => {
-          if (input.length === 0) {
-            return "Please select at least one environment.";
-          }
-          return true;
-        },
-      },
-    ]);
-
-    return answers.environments;
+    return this.selectFromEnvironments(
+      getGlobalCapableEnvironments(),
+      "Select AI environments for global setup (use space to select, enter to confirm):",
+      "No environments support global setup."
+    );
   }
 
   async selectSkillEnvironments(): Promise<EnvironmentCode[]> {
-    const skillCapableEnvs = getSkillCapableEnvironments();
-
-    if (skillCapableEnvs.length === 0) {
-      console.log("No environments support skills.");
-      return [];
-    }
-
-    const choices = skillCapableEnvs.map((env) => ({
-      name: env.name,
-      value: env.code as EnvironmentCode,
-      short: env.name,
-    }));
-
-    const answers = await inquirer.prompt([
-      {
-        type: "checkbox",
-        name: "environments",
-        message:
-          "Select AI environments for skill installation (use space to select, enter to confirm):",
-        choices,
-        pageSize: 10,
-        validate: (input: EnvironmentCode[]) => {
-          if (input.length === 0) {
-            return "Please select at least one environment.";
-          }
-          return true;
-        },
-      },
-    ]);
+    return this.selectFromEnvironments(
+      getSkillCapableEnvironments(),
+      "Select AI environments for skill installation (use space to select, enter to confirm):",
+      "No environments support skills."
+    );
+  }
 
-    return answers.environments;
+  async selectGlobalSkillEnvironments(): Promise<EnvironmentCode[]> {
+    return this.selectFromEnvironments(
+      getAllEnvironments().filter(env => env.globalSkillPath !== undefined),
+      "Select AI environments for global skill installation (use space to select, enter to confirm):",
+      "No environments support global skill installation."
+    );
   }
 }