Implement global setup to support Codex

Author: codeaholicguy

CHANGELOG.md

@@ -5,6 +5,16 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [Unreleased]
+
+### Added
+- **Global Setup Command** - New `ai-devkit setup --global` command for installing commands globally
+  - Copy AI DevKit commands to global environment folders
+  - Support for Antigravity (`~/.gemini/antigravity/global_workflows/`) and Codex (`~/.codex/prompts/`)
+  - Interactive environment selection with only global-capable environments shown
+  - Overwrite prompts for existing global commands
+  - Cross-platform support using `os.homedir()` and `path.join()`
+
 ## [0.5.0] - 2025-01-15
 
 ### Added

docs/ai/planning/feature-global-setup.md

@@ -10,31 +10,31 @@ feature: global-setup
 ## Milestones
 **What are the major checkpoints?**
 
-- [ ] Milestone 1: Environment definitions updated with global support
-- [ ] Milestone 2: Core global setup functionality implemented
-- [ ] Milestone 3: CLI command integrated and tested
+- [x] Milestone 1: Environment definitions updated with global support
+- [x] Milestone 2: Core global setup functionality implemented
+- [x] Milestone 3: CLI command integrated and tested
 
 ## Task Breakdown
 **What specific work needs to be done?**
 
 ### Phase 1: Foundation - Update Types and Environment Definitions
-- [ ] Task 1.1: Add `globalCommandPath` property to `EnvironmentDefinition` interface in `src/types.ts`
-- [ ] Task 1.2: Add `globalCommandPath` to Antigravity definition in `src/util/env.ts`
-- [ ] Task 1.3: Add `globalCommandPath` to Codex definition in `src/util/env.ts`
-- [ ] Task 1.4: Add `getGlobalCapableEnvironments()` function in `src/util/env.ts`
-- [ ] Task 1.5: Add `hasGlobalSupport()` function in `src/util/env.ts`
+- [x] Task 1.1: Add `globalCommandPath` property to `EnvironmentDefinition` interface in `src/types.ts`
+- [x] Task 1.2: Add `globalCommandPath` to Antigravity definition in `src/util/env.ts`
+- [x] Task 1.3: Add `globalCommandPath` to Codex definition in `src/util/env.ts`
+- [x] Task 1.4: Add `getGlobalCapableEnvironments()` function in `src/util/env.ts`
+- [x] Task 1.5: Add `hasGlobalSupport()` function in `src/util/env.ts`
 
 ### Phase 2: Core Features - Implement Global Setup Logic
-- [ ] Task 2.1: Add `selectGlobalEnvironments()` method to `EnvironmentSelector` class
-- [ ] Task 2.2: Add `copyCommandsToGlobal()` method to `TemplateManager` class
-- [ ] Task 2.3: Add `checkGlobalCommandsExist()` method to `TemplateManager` class
-- [ ] Task 2.4: Create new `src/commands/setup.ts` file with global setup logic
+- [x] Task 2.1: Add `selectGlobalEnvironments()` method to `EnvironmentSelector` class
+- [x] Task 2.2: Add `copyCommandsToGlobal()` method to `TemplateManager` class
+- [x] Task 2.3: Add `checkGlobalCommandsExist()` method to `TemplateManager` class
+- [x] Task 2.4: Create new `src/commands/setup.ts` file with global setup logic
 
 ### Phase 3: Integration & Polish
-- [ ] Task 3.1: Add `setup` command to CLI in `src/cli.ts`
-- [ ] Task 3.2: Add user-friendly messages and error handling
-- [ ] Task 3.3: Update CHANGELOG.md with new feature
-- [ ] Task 3.4: Test end-to-end with Antigravity and Codex
+- [x] Task 3.1: Add `setup` command to CLI in `src/cli.ts`
+- [x] Task 3.2: Add user-friendly messages and error handling
+- [x] Task 3.3: Update CHANGELOG.md with new feature
+- [x] Task 3.4: Test end-to-end with Antigravity and Codex
 
 ## Dependencies
 **What needs to happen in what order?**

docs/ai/testing/feature-global-setup.md

@@ -18,27 +18,27 @@ feature: global-setup
 **What individual components need testing?**
 
 ### `src/util/env.ts` - New Functions
-- [ ] `getGlobalCapableEnvironments()` returns only envs with `globalCommandPath`
-- [ ] `getGlobalCapableEnvironments()` returns empty array if no envs have global support
-- [ ] `hasGlobalSupport()` returns true for Antigravity
-- [ ] `hasGlobalSupport()` returns true for Codex
-- [ ] `hasGlobalSupport()` returns false for Cursor (no global support)
+- [x] `getGlobalCapableEnvironments()` returns only envs with `globalCommandPath`
+- [x] `getGlobalCapableEnvironments()` returns empty array if no envs have global support
+- [x] `hasGlobalSupport()` returns true for Antigravity
+- [x] `hasGlobalSupport()` returns true for Codex
+- [x] `hasGlobalSupport()` returns false for Cursor (no global support)
 
 ### `src/lib/EnvironmentSelector.ts` - selectGlobalEnvironments
-- [ ] Returns empty array if user selects nothing
-- [ ] Returns only global-capable environments in choices
-- [ ] Does not show environments without `globalCommandPath`
+- [x] Returns empty array if user selects nothing
+- [x] Returns only global-capable environments in choices
+- [x] Does not show environments without `globalCommandPath`
 
 ### `src/lib/TemplateManager.ts` - copyCommandsToGlobal
-- [ ] Creates global directory if it doesn't exist
-- [ ] Copies all command files to global folder
-- [ ] Uses correct file extension for each environment
-- [ ] Returns list of copied files
+- [x] Creates global directory if it doesn't exist
+- [x] Copies all command files to global folder
+- [x] Uses correct file extension for each environment
+- [x] Returns list of copied files
 
 ### `src/lib/TemplateManager.ts` - checkGlobalCommandsExist
-- [ ] Returns true if any command file exists in global folder
-- [ ] Returns false if global folder is empty
-- [ ] Returns false if global folder doesn't exist
+- [x] Returns true if any command file exists in global folder
+- [x] Returns false if global folder is empty
+- [x] Returns false if global folder doesn't exist
 
 ## Integration Tests
 **How do we test component interactions?**

src/__tests__/lib/EnvironmentSelector.test.ts

@@ -117,7 +117,7 @@ describe('EnvironmentSelector', () => {
     let consoleSpy: jest.SpyInstance;
 
     beforeEach(() => {
-      consoleSpy = jest.spyOn(console, 'log').mockImplementation(() => {});
+      consoleSpy = jest.spyOn(console, 'log').mockImplementation(() => { });
     });
 
     afterEach(() => {
@@ -148,4 +148,76 @@ describe('EnvironmentSelector', () => {
       expect(consoleSpy).toHaveBeenCalledWith('');
     });
   });
+
+  describe('selectGlobalEnvironments', () => {
+    it('should create choices only from global-capable environments', async () => {
+      mockPrompt.mockResolvedValue({ environments: ['antigravity'] });
+
+      await selector.selectGlobalEnvironments();
+
+      expect(mockPrompt).toHaveBeenCalledWith([
+        expect.objectContaining({
+          type: 'checkbox',
+          name: 'environments',
+          message: 'Select AI environments for global setup (use space to select, enter to confirm):',
+          choices: expect.arrayContaining([
+            expect.objectContaining({ value: 'antigravity' }),
+            expect.objectContaining({ value: 'codex' })
+          ]),
+          validate: expect.any(Function)
+        })
+      ]);
+    });
+
+    it('should return selected global environments', async () => {
+      const selectedEnvs = ['antigravity', 'codex'];
+      mockPrompt.mockResolvedValue({ environments: selectedEnvs });
+
+      const result = await selector.selectGlobalEnvironments();
+
+      expect(result).toEqual(selectedEnvs);
+    });
+
+    it('should validate that at least one environment is selected', async () => {
+      mockPrompt.mockResolvedValue({ environments: [] });
+
+      const result = await selector.selectGlobalEnvironments();
+
+      expect(result).toEqual([]);
+
+      const callArgs = mockPrompt.mock.calls[0][0];
+      const validateFn = callArgs[0].validate;
+
+      expect(validateFn([])).toBe('Please select at least one environment.');
+      expect(validateFn(['antigravity'])).toBe(true);
+    });
+
+    it('should not include non-global environments in choices', async () => {
+      mockPrompt.mockResolvedValue({ environments: ['antigravity'] });
+
+      await selector.selectGlobalEnvironments();
+
+      const callArgs = mockPrompt.mock.calls[0][0];
+      const choices = callArgs[0].choices;
+      const choiceValues = choices.map((c: any) => c.value);
+
+      // Should only have Antigravity and Codex
+      expect(choiceValues).toContain('antigravity');
+      expect(choiceValues).toContain('codex');
+      expect(choiceValues).not.toContain('cursor');
+      expect(choiceValues).not.toContain('claude');
+      expect(choiceValues).not.toContain('github');
+    });
+
+    it('should show exactly 2 choices (Antigravity and Codex)', async () => {
+      mockPrompt.mockResolvedValue({ environments: [] });
+
+      await selector.selectGlobalEnvironments();
+
+      const callArgs = mockPrompt.mock.calls[0][0];
+      const choices = callArgs[0].choices;
+
+      expect(choices).toHaveLength(2);
+    });
+  });
 });