aios-core 2.1.0

package/packages/installer/tests/unit/detection/detect-project-type.test.js

@@ -0,0 +1,401 @@
+const fs = require('fs');
+const path = require('path');
+const { detectProjectType } = require('../../../src/detection/detect-project-type');
+
+// Mock fs module
+jest.mock('fs');
+
+describe('detectProjectType', () => {
+  beforeEach(() => {
+    // Clear all mocks before each test
+    jest.clearAllMocks();
+    
+    // Reset console.error mock to avoid test pollution
+    jest.spyOn(console, 'error').mockImplementation(() => {});
+  });
+
+  afterEach(() => {
+    // Restore console.error
+    console.error.mockRestore();
+  });
+
+  // ============================================================================
+  // AC #1: Empty Directory → GREENFIELD
+  // ============================================================================
+  describe('AC #1: GREENFIELD detection', () => {
+    test('detects GREENFIELD when directory is empty', () => {
+      // Setup: Directory exists but has no files
+      fs.existsSync.mockImplementation((checkPath) => {
+        // Directory exists, but no markers
+        if (checkPath === path.resolve('/test/empty')) return true;
+        return false; // No .aios-core, package.json, or .git
+      });
+      fs.readdirSync.mockReturnValue([]); // Empty directory
+      
+      const result = detectProjectType('/test/empty');
+      
+      expect(result).toBe('GREENFIELD');
+      expect(fs.existsSync).toHaveBeenCalledWith(expect.stringContaining('.aios-core'));
+      expect(fs.readdirSync).toHaveBeenCalledTimes(1);
+    });
+
+    test('uses process.cwd() as default when no targetDir provided', () => {
+      // Setup
+      const mockCwd = process.cwd();
+      fs.existsSync.mockImplementation((checkPath) => {
+        if (checkPath === path.resolve(mockCwd)) return true;
+        return false;
+      });
+      fs.readdirSync.mockReturnValue([]);
+      
+      const result = detectProjectType();
+      
+      expect(result).toBe('GREENFIELD');
+      expect(fs.readdirSync).toHaveBeenCalledWith(path.resolve(mockCwd));
+    });
+  });
+
+  // ============================================================================
+  // AC #2: package.json Exists → BROWNFIELD
+  // ============================================================================
+  describe('AC #2: BROWNFIELD detection - package.json', () => {
+    test('detects BROWNFIELD when package.json exists', () => {
+      // Setup
+      fs.existsSync.mockImplementation((checkPath) => {
+        if (checkPath === path.resolve('/test/brownfield')) return true;
+        if (checkPath.endsWith('package.json')) return true; // package.json exists
+        return false; // No .aios-core or .git
+      });
+      fs.readdirSync.mockReturnValue(['package.json', 'src', 'README.md']);
+      
+      const result = detectProjectType('/test/brownfield');
+      
+      expect(result).toBe('BROWNFIELD');
+    });
+
+    test('detects BROWNFIELD when only package.json exists (no git)', () => {
+      // Setup: package.json but no .git
+      fs.existsSync.mockImplementation((checkPath) => {
+        if (checkPath === path.resolve('/test/node-project')) return true;
+        if (checkPath.endsWith('package.json')) return true;
+        if (checkPath.endsWith('.git')) return false;
+        if (checkPath.endsWith('.aios-core')) return false;
+        return false;
+      });
+      fs.readdirSync.mockReturnValue(['package.json', 'index.js']);
+      
+      const result = detectProjectType('/test/node-project');
+      
+      expect(result).toBe('BROWNFIELD');
+    });
+  });
+
+  // ============================================================================
+  // AC #3: .git Exists → BROWNFIELD
+  // ============================================================================
+  describe('AC #3: BROWNFIELD detection - .git', () => {
+    test('detects BROWNFIELD when .git exists', () => {
+      // Setup
+      fs.existsSync.mockImplementation((checkPath) => {
+        if (checkPath === path.resolve('/test/brownfield-git')) return true;
+        if (checkPath.endsWith('.git')) return true; // .git exists
+        return false; // No .aios-core or package.json
+      });
+      fs.readdirSync.mockReturnValue(['.git', 'README.md', 'src']);
+      
+      const result = detectProjectType('/test/brownfield-git');
+      
+      expect(result).toBe('BROWNFIELD');
+    });
+
+    test('detects BROWNFIELD when both package.json and .git exist', () => {
+      // Setup: Both markers present
+      fs.existsSync.mockImplementation((checkPath) => {
+        if (checkPath === path.resolve('/test/full-project')) return true;
+        if (checkPath.endsWith('package.json')) return true;
+        if (checkPath.endsWith('.git')) return true;
+        if (checkPath.endsWith('.aios-core')) return false;
+        return false;
+      });
+      fs.readdirSync.mockReturnValue(['.git', 'package.json', 'src', 'README.md']);
+      
+      const result = detectProjectType('/test/full-project');
+      
+      expect(result).toBe('BROWNFIELD');
+    });
+  });
+
+  // ============================================================================
+  // AC #4: .aios-core Exists → EXISTING_AIOS
+  // ============================================================================
+  describe('AC #4: EXISTING_AIOS detection', () => {
+    test('detects EXISTING_AIOS when .aios-core exists', () => {
+      // Setup
+      fs.existsSync.mockImplementation((checkPath) => {
+        if (checkPath === path.resolve('/test/existing')) return true;
+        if (checkPath.endsWith('.aios-core')) return true; // .aios-core exists
+        return true; // Other files may exist too
+      });
+      fs.readdirSync.mockReturnValue(['.aios-core', 'package.json', '.git', 'src']);
+      
+      const result = detectProjectType('/test/existing');
+      
+      expect(result).toBe('EXISTING_AIOS');
+    });
+
+    test('EXISTING_AIOS takes priority over BROWNFIELD markers', () => {
+      // Setup: All markers present, but EXISTING_AIOS should win
+      fs.existsSync.mockImplementation((checkPath) => {
+        if (checkPath === path.resolve('/test/priority-test')) return true;
+        // All markers present
+        if (checkPath.endsWith('.aios-core')) return true;
+        if (checkPath.endsWith('package.json')) return true;
+        if (checkPath.endsWith('.git')) return true;
+        return false;
+      });
+      fs.readdirSync.mockReturnValue(['.aios-core', 'package.json', '.git', 'src']);
+      
+      const result = detectProjectType('/test/priority-test');
+      
+      // EXISTING_AIOS has highest priority
+      expect(result).toBe('EXISTING_AIOS');
+    });
+  });
+
+  // ============================================================================
+  // Edge Case: UNKNOWN Type
+  // ============================================================================
+  describe('Edge Case: UNKNOWN detection', () => {
+    test('returns UNKNOWN when directory has files but no recognized markers', () => {
+      // Setup: Files exist but no package.json, .git, or .aios-core
+      fs.existsSync.mockImplementation((checkPath) => {
+        if (checkPath === path.resolve('/test/unknown')) return true;
+        // No recognized markers
+        return false;
+      });
+      fs.readdirSync.mockReturnValue(['README.md', 'index.html', 'styles.css']);
+      
+      const result = detectProjectType('/test/unknown');
+      
+      expect(result).toBe('UNKNOWN');
+    });
+
+    test('returns UNKNOWN for non-empty directory with only hidden files', () => {
+      // Setup
+      fs.existsSync.mockImplementation((checkPath) => {
+        if (checkPath === path.resolve('/test/hidden-only')) return true;
+        return false; // No recognized markers
+      });
+      fs.readdirSync.mockReturnValue(['.DS_Store', '.gitignore']); // Hidden files only
+      
+      const result = detectProjectType('/test/hidden-only');
+      
+      expect(result).toBe('UNKNOWN');
+    });
+  });
+
+  // ============================================================================
+  // Error Handling Tests
+  // ============================================================================
+  describe('Error Handling', () => {
+    test('throws error when directory does not exist', () => {
+      // Setup: Directory doesn't exist
+      fs.existsSync.mockImplementation((checkPath) => {
+        if (checkPath === path.resolve('/test/nonexistent')) return false;
+        return false;
+      });
+      
+      expect(() => detectProjectType('/test/nonexistent')).toThrow('Failed to detect project type');
+      expect(() => detectProjectType('/test/nonexistent')).toThrow('Directory does not exist');
+    });
+
+    test('throws error when directory cannot be accessed (EACCES)', () => {
+      // Setup: Permission denied error
+      const permissionError = new Error('EACCES: permission denied');
+      permissionError.code = 'EACCES';
+      
+      fs.existsSync.mockImplementation((checkPath) => {
+        if (checkPath === path.resolve('/test/denied')) return true;
+        if (checkPath.endsWith('.aios-core')) {
+          throw permissionError;
+        }
+        return false;
+      });
+      
+      expect(() => detectProjectType('/test/denied')).toThrow('Failed to detect project type');
+      expect(console.error).toHaveBeenCalledWith(
+        expect.stringContaining('[detect-project-type] Error detecting project type'),
+      );
+    });
+
+    test('throws error when fs.readdirSync fails', () => {
+      // Setup: readdirSync throws error
+      const readError = new Error('EPERM: operation not permitted');
+      readError.code = 'EPERM';
+      
+      fs.existsSync.mockImplementation((checkPath) => {
+        if (checkPath === path.resolve('/test/read-error')) return true;
+        return false;
+      });
+      fs.readdirSync.mockImplementation(() => {
+        throw readError;
+      });
+      
+      expect(() => detectProjectType('/test/read-error')).toThrow('Failed to detect project type');
+      expect(console.error).toHaveBeenCalled();
+    });
+
+    test('throws error with invalid targetDir parameter (null)', () => {
+      expect(() => detectProjectType(null)).toThrow('Invalid targetDir parameter');
+    });
+
+    test('throws error with invalid targetDir parameter (empty string)', () => {
+      expect(() => detectProjectType('')).toThrow('Invalid targetDir parameter');
+    });
+
+    test('throws error with invalid targetDir parameter (number)', () => {
+      expect(() => detectProjectType(123)).toThrow('Invalid targetDir parameter');
+    });
+  });
+
+  // ============================================================================
+  // Priority Order Verification
+  // ============================================================================
+  describe('Detection Priority Order', () => {
+    test('priority: EXISTING_AIOS > GREENFIELD', () => {
+      // Even if directory appears empty, .aios-core presence should win
+      fs.existsSync.mockImplementation((checkPath) => {
+        if (checkPath === path.resolve('/test/priority1')) return true;
+        if (checkPath.endsWith('.aios-core')) return true;
+        return false;
+      });
+      fs.readdirSync.mockReturnValue(['.aios-core']); // Only .aios-core
+      
+      const result = detectProjectType('/test/priority1');
+      
+      expect(result).toBe('EXISTING_AIOS');
+    });
+
+    test('priority: GREENFIELD > BROWNFIELD when directory is empty', () => {
+      // This test verifies the order, though practically impossible scenario
+      fs.existsSync.mockImplementation((checkPath) => {
+        if (checkPath === path.resolve('/test/priority2')) return true;
+        return false; // No markers
+      });
+      fs.readdirSync.mockReturnValue([]); // Empty
+      
+      const result = detectProjectType('/test/priority2');
+      
+      expect(result).toBe('GREENFIELD');
+    });
+
+    test('priority: BROWNFIELD > UNKNOWN', () => {
+      // Directory has files + package.json
+      fs.existsSync.mockImplementation((checkPath) => {
+        if (checkPath === path.resolve('/test/priority3')) return true;
+        if (checkPath.endsWith('package.json')) return true;
+        if (checkPath.endsWith('.aios-core')) return false;
+        if (checkPath.endsWith('.git')) return false;
+        return false;
+      });
+      fs.readdirSync.mockReturnValue(['package.json', 'other-file.txt']);
+      
+      const result = detectProjectType('/test/priority3');
+      
+      expect(result).toBe('BROWNFIELD');
+    });
+  });
+
+  // ============================================================================
+  // Cross-Platform Path Handling
+  // ============================================================================
+  describe('Cross-Platform Compatibility', () => {
+    test('handles Windows-style paths correctly', () => {
+      const windowsPath = 'C:\\Users\\Test\\project';
+      
+      fs.existsSync.mockImplementation((checkPath) => {
+        if (checkPath === path.resolve(windowsPath)) return true;
+        return false;
+      });
+      fs.readdirSync.mockReturnValue([]);
+      
+      const result = detectProjectType(windowsPath);
+      
+      expect(result).toBe('GREENFIELD');
+      expect(fs.existsSync).toHaveBeenCalledWith(expect.any(String));
+    });
+
+    test('handles Unix-style paths correctly', () => {
+      const unixPath = '/home/user/project';
+      
+      fs.existsSync.mockImplementation((checkPath) => {
+        if (checkPath === path.resolve(unixPath)) return true;
+        return false;
+      });
+      fs.readdirSync.mockReturnValue([]);
+      
+      const result = detectProjectType(unixPath);
+      
+      expect(result).toBe('GREENFIELD');
+    });
+
+    test('normalizes relative paths correctly', () => {
+      const relativePath = './test/project';
+      
+      fs.existsSync.mockImplementation((checkPath) => {
+        if (checkPath === path.resolve(relativePath)) return true;
+        return false;
+      });
+      fs.readdirSync.mockReturnValue([]);
+      
+      const result = detectProjectType(relativePath);
+      
+      expect(result).toBe('GREENFIELD');
+    });
+  });
+
+  // ============================================================================
+  // Security Tests
+  // ============================================================================
+  describe('Security - Path Traversal Prevention', () => {
+    test('uses path.join for all file checks (prevents traversal)', () => {
+      fs.existsSync.mockImplementation((checkPath) => {
+        if (checkPath === path.resolve('/test/secure')) return true;
+        // Verify path.join was used (no string concatenation)
+        expect(checkPath).toContain(path.sep);
+        return false;
+      });
+      fs.readdirSync.mockReturnValue([]);
+      
+      detectProjectType('/test/secure');
+      
+      // Verify all existsSync calls use proper path joining
+      expect(fs.existsSync).toHaveBeenCalledWith(expect.stringContaining(path.sep));
+    });
+
+    test('normalizes path to prevent directory traversal attacks', () => {
+      const maliciousPath = '/test/../../etc/passwd';
+      const resolvedPath = path.resolve(maliciousPath);
+      
+      fs.existsSync.mockImplementation((checkPath) => {
+        // Directory exists
+        if (checkPath === resolvedPath) return true;
+        // Verify all paths contain the normalized base path
+        if (checkPath.includes(resolvedPath)) return false;
+        return false;
+      });
+      fs.readdirSync.mockReturnValue([]);
+      
+      const result = detectProjectType(maliciousPath);
+      
+      expect(result).toBe('GREENFIELD');
+      expect(fs.existsSync).toHaveBeenCalled();
+      // Verify the normalized path was used as base
+      const calls = fs.existsSync.mock.calls;
+      calls.forEach(([callPath]) => {
+        expect(callPath).toContain(path.normalize(resolvedPath).split(path.sep)[0]);
+      });
+    });
+  });
+});
+

package/packages/installer/tests/unit/env-template.test.js

@@ -0,0 +1,185 @@
+/**
+ * Unit Tests: .env Template Generator
+ * Story 1.6: Environment Configuration
+ *
+ * Tests for env-template.js
+ */
+
+const { generateEnvContent, generateEnvExample } = require('../../src/config/templates/env-template');
+
+describe('.env Template Generator', () => {
+  describe('generateEnvContent', () => {
+    it('should generate .env with empty API keys when none provided', () => {
+      const content = generateEnvContent();
+
+      expect(content).toContain('NODE_ENV=development');
+      expect(content).toContain('AIOS_VERSION=2.1.0');
+      expect(content).toContain('OPENAI_API_KEY=');
+      expect(content).toContain('ANTHROPIC_API_KEY=');
+      expect(content).toContain('# AIOS Environment Configuration');
+    });
+
+    it('should generate .env with provided API keys', () => {
+      const apiKeys = {
+        openai: 'sk-test-openai-key',
+        anthropic: 'sk-ant-test-anthropic-key',
+      };
+
+      const content = generateEnvContent(apiKeys);
+
+      expect(content).toContain('OPENAI_API_KEY=sk-test-openai-key');
+      expect(content).toContain('ANTHROPIC_API_KEY=sk-ant-test-anthropic-key');
+    });
+
+    it('should generate .env with optional service API keys', () => {
+      const apiKeys = {
+        clickup: 'clickup-test-key',
+        github: 'ghp-test-token',
+        exa: 'exa-test-key',
+      };
+
+      const content = generateEnvContent(apiKeys);
+
+      expect(content).toContain('CLICKUP_API_KEY=clickup-test-key');
+      expect(content).toContain('GITHUB_TOKEN=ghp-test-token');
+      expect(content).toContain('EXA_API_KEY=exa-test-key');
+    });
+
+    it('should include helpful comments', () => {
+      const content = generateEnvContent();
+
+      expect(content).toContain('# AI Providers');
+      expect(content).toContain('# Optional Services');
+      expect(content).toContain('# Get yours at:');
+    });
+
+    it('should not contain sensitive data in comments', () => {
+      const content = generateEnvContent();
+
+      // Should not have example API keys or credentials in comments
+      expect(content).not.toMatch(/sk-[a-zA-Z0-9]{20,}/);
+      expect(content).not.toMatch(/example.*key.*[a-zA-Z0-9]{20,}/i);
+    });
+
+    it('should use KEY=value format without spaces', () => {
+      const apiKeys = { openai: 'test-key' };
+      const content = generateEnvContent(apiKeys);
+
+      // Check no spaces around =
+      const lines = content.split('\n').filter(line => !line.startsWith('#') && line.trim());
+      lines.forEach(line => {
+        if (line.includes('=')) {
+          expect(line).toMatch(/^[A-Z_]+=.*/);
+          // Check there are NO spaces before or after the = sign
+          expect(line).not.toMatch(/\s=/); // No space before =
+          expect(line).not.toMatch(/=\s[^=]*$/); // No space after = (except in comments)
+        }
+      });
+    });
+  });
+
+  describe('generateEnvExample', () => {
+    it('should generate .env.example with empty values', () => {
+      const content = generateEnvExample();
+
+      expect(content).toContain('NODE_ENV=development');
+      expect(content).toContain('AIOS_VERSION=2.1.0');
+      expect(content).toContain('OPENAI_API_KEY=');
+      expect(content).toContain('ANTHROPIC_API_KEY=');
+      expect(content).toContain('CLICKUP_API_KEY=');
+    });
+
+    it('should not contain any actual API keys', () => {
+      const content = generateEnvExample();
+
+      // All API key fields should be empty
+      const apiKeyLines = content.split('\n').filter(line =>
+        line.includes('_API_KEY=') || line.includes('_TOKEN='),
+      );
+
+      apiKeyLines.forEach(line => {
+        const [, value] = line.split('=');
+        expect(value.trim()).toBe('');
+      });
+    });
+
+    it('should include helpful comments with links', () => {
+      const content = generateEnvExample();
+
+      expect(content).toContain('https://platform.openai.com');
+      expect(content).toContain('https://console.anthropic.com');
+      expect(content).toContain('https://app.clickup.com');
+      expect(content).toContain('https://github.com/settings/tokens');
+    });
+
+    it('should be safe to commit', () => {
+      const content = generateEnvExample();
+
+      // Should not contain any of these sensitive patterns
+      const sensitivePatterns = [
+        /sk-[a-zA-Z0-9]{20,}/, // OpenAI keys
+        /sk-ant-[a-zA-Z0-9]{30,}/, // Anthropic keys
+        /ghp_[a-zA-Z0-9]+/, // GitHub tokens
+      ];
+
+      sensitivePatterns.forEach(pattern => {
+        expect(content).not.toMatch(pattern);
+      });
+
+      // Check that no API key fields have actual values (only empty or commented)
+      const lines = content.split('\n').filter(line => !line.trim().startsWith('#'));
+      lines.forEach(line => {
+        if (line.includes('PASSWORD') || line.includes('SECRET') || line.includes('KEY') || line.includes('TOKEN')) {
+          const [key, value] = line.split('=');
+          if (value !== undefined) {
+            expect(value.trim()).toBe('');
+          }
+        }
+      });
+    });
+
+    it('should match .env structure but with empty values', () => {
+      const envContent = generateEnvContent({ openai: 'test', anthropic: 'test' });
+      const exampleContent = generateEnvExample();
+
+      // Extract non-comment, non-empty lines
+      const envKeys = envContent.split('\n')
+        .filter(line => line.trim() && !line.startsWith('#'))
+        .map(line => line.split('=')[0]);
+
+      const exampleKeys = exampleContent.split('\n')
+        .filter(line => line.trim() && !line.startsWith('#'))
+        .map(line => line.split('=')[0]);
+
+      // Both should have the same keys
+      expect(exampleKeys.sort()).toEqual(envKeys.sort());
+    });
+  });
+
+  describe('Content Quality', () => {
+    it('should have proper line endings', () => {
+      const content = generateEnvContent();
+
+      // Should use \n for line endings
+      expect(content).not.toContain('\r\n');
+      expect(content.split('\n').length).toBeGreaterThan(10);
+    });
+
+    it('should organize content in sections', () => {
+      const content = generateEnvContent();
+
+      // Should have clear section headers
+      expect(content).toContain('# AIOS Core Configuration');
+      expect(content).toContain('# AI Providers');
+      expect(content).toContain('# Optional Services');
+    });
+
+    it('should include usage instructions', () => {
+      const content = generateEnvContent();
+
+      // Should help users understand what to do
+      expect(content).toContain('DO NOT commit');
+      expect(content).toContain('Get yours at:');
+    });
+  });
+});