@l4yercak3/cli 1.0.0

package/tests/commands/status.test.js

@@ -0,0 +1,167 @@
+/**
+ * Tests for Status Command
+ */
+
+jest.mock('../../src/config/config-manager');
+jest.mock('../../src/api/backend-client');
+jest.mock('chalk', () => ({
+  bold: (str) => str,
+  red: (str) => str,
+  green: (str) => str,
+  yellow: (str) => str,
+  gray: (str) => str,
+}));
+
+const configManager = require('../../src/config/config-manager');
+const backendClient = require('../../src/api/backend-client');
+const statusCommand = require('../../src/commands/status');
+
+describe('Status Command', () => {
+  let consoleOutput = [];
+  const originalConsoleLog = console.log;
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+    consoleOutput = [];
+    console.log = jest.fn((...args) => {
+      consoleOutput.push(args.join(' '));
+    });
+    configManager.getBackendUrl.mockReturnValue('https://backend.test.com');
+  });
+
+  afterEach(() => {
+    console.log = originalConsoleLog;
+  });
+
+  describe('module exports', () => {
+    it('exports command name', () => {
+      expect(statusCommand.command).toBe('status');
+    });
+
+    it('exports description', () => {
+      expect(statusCommand.description).toBe('Show authentication status');
+    });
+
+    it('exports handler function', () => {
+      expect(typeof statusCommand.handler).toBe('function');
+    });
+  });
+
+  describe('handler - not logged in', () => {
+    beforeEach(() => {
+      configManager.isLoggedIn.mockReturnValue(false);
+      configManager.getSession.mockReturnValue(null);
+    });
+
+    it('shows not logged in message', async () => {
+      await statusCommand.handler();
+
+      expect(consoleOutput.some((line) => line.includes('Not logged in'))).toBe(true);
+    });
+
+    it('shows login hint', async () => {
+      await statusCommand.handler();
+
+      expect(consoleOutput.some((line) => line.includes('l4yercak3 login'))).toBe(true);
+    });
+
+    it('does not validate session with backend', async () => {
+      await statusCommand.handler();
+
+      expect(backendClient.validateSession).not.toHaveBeenCalled();
+    });
+  });
+
+  describe('handler - logged in', () => {
+    beforeEach(() => {
+      configManager.isLoggedIn.mockReturnValue(true);
+    });
+
+    it('shows logged in status', async () => {
+      configManager.getSession.mockReturnValue({ token: 'test-token' });
+      backendClient.validateSession.mockResolvedValue(null);
+
+      await statusCommand.handler();
+
+      expect(consoleOutput.some((line) => line.includes('Logged in'))).toBe(true);
+    });
+
+    it('displays email when available', async () => {
+      configManager.getSession.mockReturnValue({
+        token: 'test-token',
+        email: 'user@example.com',
+      });
+      backendClient.validateSession.mockResolvedValue(null);
+
+      await statusCommand.handler();
+
+      expect(consoleOutput.some((line) => line.includes('user@example.com'))).toBe(true);
+    });
+
+    it('displays expiration with days remaining', async () => {
+      const futureDate = Date.now() + 5 * 24 * 60 * 60 * 1000; // 5 days
+      configManager.getSession.mockReturnValue({
+        token: 'test-token',
+        expiresAt: futureDate,
+      });
+      backendClient.validateSession.mockResolvedValue(null);
+
+      await statusCommand.handler();
+
+      // Check that session expiration info is shown (days may vary based on timing)
+      expect(consoleOutput.some((line) => line.includes('Session expires'))).toBe(true);
+    });
+
+    it('shows expired warning when session expired', async () => {
+      const pastDate = Date.now() - 24 * 60 * 60 * 1000; // Yesterday
+      configManager.getSession.mockReturnValue({
+        token: 'test-token',
+        expiresAt: pastDate,
+      });
+      backendClient.validateSession.mockResolvedValue(null);
+
+      await statusCommand.handler();
+
+      expect(consoleOutput.some((line) => line.includes('expired'))).toBe(true);
+    });
+
+    it('validates session with backend', async () => {
+      configManager.getSession.mockReturnValue({ token: 'test-token' });
+      backendClient.validateSession.mockResolvedValue({ userId: '123' });
+
+      await statusCommand.handler();
+
+      expect(backendClient.validateSession).toHaveBeenCalled();
+    });
+
+    it('displays backend URL on successful validation', async () => {
+      configManager.getSession.mockReturnValue({ token: 'test-token' });
+      backendClient.validateSession.mockResolvedValue({ userId: '123' });
+
+      await statusCommand.handler();
+
+      expect(consoleOutput.some((line) => line.includes('Backend URL'))).toBe(true);
+    });
+
+    it('displays organization count when available', async () => {
+      configManager.getSession.mockReturnValue({ token: 'test-token' });
+      backendClient.validateSession.mockResolvedValue({
+        userId: '123',
+        organizations: [{ id: '1' }, { id: '2' }],
+      });
+
+      await statusCommand.handler();
+
+      expect(consoleOutput.some((line) => line.includes('Organizations: 2'))).toBe(true);
+    });
+
+    it('handles backend validation error gracefully', async () => {
+      configManager.getSession.mockReturnValue({ token: 'test-token' });
+      backendClient.validateSession.mockRejectedValue(new Error('Network error'));
+
+      await statusCommand.handler();
+
+      expect(consoleOutput.some((line) => line.includes('Could not validate session'))).toBe(true);
+    });
+  });
+});

package/tests/config-manager.test.js

@@ -0,0 +1,313 @@
+/**
+ * Tests for ConfigManager
+ */
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+// Mock fs module
+jest.mock('fs');
+
+// We need to require after mocking
+const ConfigManager = require('../src/config/config-manager');
+
+describe('ConfigManager', () => {
+  const mockConfigDir = path.join(os.homedir(), '.l4yercak3');
+  const mockConfigFile = path.join(mockConfigDir, 'config.json');
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+    // Default: config directory exists
+    fs.existsSync.mockImplementation((p) => {
+      if (p === mockConfigDir) return true;
+      if (p === mockConfigFile) return false;
+      return false;
+    });
+  });
+
+  describe('getConfig', () => {
+    it('returns default config when no config file exists', () => {
+      fs.existsSync.mockReturnValue(false);
+
+      const config = ConfigManager.getConfig();
+
+      expect(config).toEqual({
+        session: null,
+        organizations: [],
+        settings: {
+          backendUrl: 'https://backend.l4yercak3.com',
+        },
+      });
+    });
+
+    it('reads and parses existing config file', () => {
+      const mockConfig = {
+        session: { token: 'test-token' },
+        organizations: [{ id: '1', name: 'Test Org' }],
+        settings: { backendUrl: 'https://custom.url' },
+      };
+
+      fs.existsSync.mockReturnValue(true);
+      fs.readFileSync.mockReturnValue(JSON.stringify(mockConfig));
+
+      const config = ConfigManager.getConfig();
+
+      expect(config).toEqual(mockConfig);
+      expect(fs.readFileSync).toHaveBeenCalledWith(mockConfigFile, 'utf8');
+    });
+
+    it('returns default config on parse error', () => {
+      fs.existsSync.mockReturnValue(true);
+      fs.readFileSync.mockReturnValue('invalid json');
+
+      const config = ConfigManager.getConfig();
+
+      expect(config).toEqual({
+        session: null,
+        organizations: [],
+        settings: {},
+      });
+    });
+  });
+
+  describe('saveConfig', () => {
+    it('creates config directory if it does not exist', () => {
+      fs.existsSync.mockReturnValue(false);
+      fs.mkdirSync.mockReturnValue(undefined);
+      fs.writeFileSync.mockReturnValue(undefined);
+
+      ConfigManager.saveConfig({ test: true });
+
+      expect(fs.mkdirSync).toHaveBeenCalledWith(mockConfigDir, {
+        recursive: true,
+        mode: 0o700,
+      });
+    });
+
+    it('writes config with secure permissions', () => {
+      fs.existsSync.mockReturnValue(true);
+      fs.writeFileSync.mockReturnValue(undefined);
+
+      const config = { session: { token: 'test' } };
+      const result = ConfigManager.saveConfig(config);
+
+      expect(result).toBe(true);
+      expect(fs.writeFileSync).toHaveBeenCalledWith(
+        mockConfigFile,
+        JSON.stringify(config, null, 2),
+        { mode: 0o600 }
+      );
+    });
+
+    it('returns false on write error', () => {
+      fs.existsSync.mockReturnValue(true);
+      fs.writeFileSync.mockImplementation(() => {
+        throw new Error('Write failed');
+      });
+
+      const result = ConfigManager.saveConfig({ test: true });
+
+      expect(result).toBe(false);
+    });
+  });
+
+  describe('session management', () => {
+    it('getSession returns null when no session exists', () => {
+      fs.existsSync.mockImplementation((p) => p === mockConfigDir);
+
+      const session = ConfigManager.getSession();
+
+      expect(session).toBeNull();
+    });
+
+    it('saveSession updates session in config', () => {
+      fs.existsSync.mockReturnValue(true);
+      fs.readFileSync.mockReturnValue(JSON.stringify({
+        session: null,
+        organizations: [],
+        settings: {},
+      }));
+      fs.writeFileSync.mockReturnValue(undefined);
+
+      const session = { token: 'new-token', expiresAt: Date.now() + 3600000 };
+      ConfigManager.saveSession(session);
+
+      expect(fs.writeFileSync).toHaveBeenCalled();
+      const savedConfig = JSON.parse(fs.writeFileSync.mock.calls[0][1]);
+      expect(savedConfig.session).toEqual(session);
+    });
+
+    it('clearSession removes session from config', () => {
+      fs.existsSync.mockReturnValue(true);
+      fs.readFileSync.mockReturnValue(JSON.stringify({
+        session: { token: 'existing' },
+        organizations: [],
+        settings: {},
+      }));
+      fs.writeFileSync.mockReturnValue(undefined);
+
+      ConfigManager.clearSession();
+
+      const savedConfig = JSON.parse(fs.writeFileSync.mock.calls[0][1]);
+      expect(savedConfig.session).toBeNull();
+    });
+  });
+
+  describe('isLoggedIn', () => {
+    it('returns false when no session', () => {
+      fs.existsSync.mockImplementation((p) => p === mockConfigDir);
+
+      expect(ConfigManager.isLoggedIn()).toBe(false);
+    });
+
+    it('returns false when session expired', () => {
+      fs.existsSync.mockReturnValue(true);
+      fs.readFileSync.mockReturnValue(JSON.stringify({
+        session: {
+          token: 'test-token',
+          expiresAt: Date.now() - 1000, // Expired
+        },
+        organizations: [],
+        settings: {},
+      }));
+
+      expect(ConfigManager.isLoggedIn()).toBe(false);
+    });
+
+    it('returns true when session valid', () => {
+      fs.existsSync.mockReturnValue(true);
+      fs.readFileSync.mockReturnValue(JSON.stringify({
+        session: {
+          token: 'test-token',
+          expiresAt: Date.now() + 3600000, // Valid for 1 hour
+        },
+        organizations: [],
+        settings: {},
+      }));
+
+      expect(ConfigManager.isLoggedIn()).toBe(true);
+    });
+  });
+
+  describe('getBackendUrl', () => {
+    it('returns default URL when not configured', () => {
+      fs.existsSync.mockImplementation((p) => p === mockConfigDir);
+
+      const url = ConfigManager.getBackendUrl();
+
+      expect(url).toBe('https://backend.l4yercak3.com');
+    });
+
+    it('returns configured URL from settings', () => {
+      fs.existsSync.mockReturnValue(true);
+      fs.readFileSync.mockReturnValue(JSON.stringify({
+        session: null,
+        organizations: [],
+        settings: { backendUrl: 'https://custom.backend.com' },
+      }));
+
+      const url = ConfigManager.getBackendUrl();
+
+      expect(url).toBe('https://custom.backend.com');
+    });
+  });
+
+  describe('organization management', () => {
+    it('addOrganization adds new organization', () => {
+      fs.existsSync.mockReturnValue(true);
+      fs.readFileSync.mockReturnValue(JSON.stringify({
+        session: null,
+        organizations: [],
+        settings: {},
+      }));
+      fs.writeFileSync.mockReturnValue(undefined);
+
+      const org = { id: '123', name: 'New Org' };
+      ConfigManager.addOrganization(org);
+
+      const savedConfig = JSON.parse(fs.writeFileSync.mock.calls[0][1]);
+      expect(savedConfig.organizations).toContainEqual(org);
+    });
+
+    it('addOrganization replaces existing organization with same id', () => {
+      fs.existsSync.mockReturnValue(true);
+      fs.readFileSync.mockReturnValue(JSON.stringify({
+        session: null,
+        organizations: [{ id: '123', name: 'Old Name' }],
+        settings: {},
+      }));
+      fs.writeFileSync.mockReturnValue(undefined);
+
+      const org = { id: '123', name: 'New Name' };
+      ConfigManager.addOrganization(org);
+
+      const savedConfig = JSON.parse(fs.writeFileSync.mock.calls[0][1]);
+      expect(savedConfig.organizations).toHaveLength(1);
+      expect(savedConfig.organizations[0].name).toBe('New Name');
+    });
+
+    it('getOrganizations returns empty array when none exist', () => {
+      fs.existsSync.mockImplementation((p) => p === mockConfigDir);
+
+      const orgs = ConfigManager.getOrganizations();
+
+      expect(orgs).toEqual([]);
+    });
+  });
+
+  describe('project configuration', () => {
+    it('saveProjectConfig stores project config by path', () => {
+      fs.existsSync.mockReturnValue(true);
+      fs.readFileSync.mockReturnValue(JSON.stringify({
+        session: null,
+        organizations: [],
+        settings: {},
+      }));
+      fs.writeFileSync.mockReturnValue(undefined);
+
+      const projectPath = '/path/to/project';
+      const projectConfig = { apiKey: 'key123', features: ['crm'] };
+      ConfigManager.saveProjectConfig(projectPath, projectConfig);
+
+      const savedConfig = JSON.parse(fs.writeFileSync.mock.calls[0][1]);
+      const normalizedPath = path.resolve(projectPath);
+      expect(savedConfig.projects[normalizedPath]).toMatchObject(projectConfig);
+      expect(savedConfig.projects[normalizedPath].updatedAt).toBeDefined();
+    });
+
+    it('getProjectConfig returns null when project not found', () => {
+      fs.existsSync.mockReturnValue(true);
+      fs.readFileSync.mockReturnValue(JSON.stringify({
+        session: null,
+        organizations: [],
+        settings: {},
+        projects: {},
+      }));
+
+      const config = ConfigManager.getProjectConfig('/nonexistent/path');
+
+      expect(config).toBeNull();
+    });
+
+    it('getProjectConfig returns config for existing project', () => {
+      const projectPath = '/path/to/project';
+      const normalizedPath = path.resolve(projectPath);
+      const projectConfig = { apiKey: 'key123' };
+
+      fs.existsSync.mockReturnValue(true);
+      fs.readFileSync.mockReturnValue(JSON.stringify({
+        session: null,
+        organizations: [],
+        settings: {},
+        projects: {
+          [normalizedPath]: projectConfig,
+        },
+      }));
+
+      const config = ConfigManager.getProjectConfig(projectPath);
+
+      expect(config).toEqual(projectConfig);
+    });
+  });
+});

package/tests/detector-index.test.js

@@ -0,0 +1,209 @@
+/**
+ * Tests for Detector Index (ProjectDetector)
+ */
+
+const fs = require('fs');
+const { execSync } = require('child_process');
+const path = require('path');
+
+jest.mock('fs');
+jest.mock('child_process');
+
+const ProjectDetector = require('../src/detectors/index');
+
+describe('ProjectDetector', () => {
+  const mockProjectPath = '/test/project';
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+    fs.existsSync.mockReturnValue(false);
+    execSync.mockReturnValue('');
+  });
+
+  describe('detect', () => {
+    it('returns combined detection results', () => {
+      const result = ProjectDetector.detect(mockProjectPath);
+
+      expect(result).toHaveProperty('framework');
+      expect(result).toHaveProperty('github');
+      expect(result).toHaveProperty('apiClient');
+      expect(result).toHaveProperty('oauth');
+      expect(result).toHaveProperty('projectPath');
+      expect(result).toHaveProperty('_raw');
+    });
+
+    it('includes projectPath in results', () => {
+      const result = ProjectDetector.detect(mockProjectPath);
+
+      expect(result.projectPath).toBe(mockProjectPath);
+    });
+
+    describe('framework detection', () => {
+      it('returns null type when no framework detected', () => {
+        const result = ProjectDetector.detect(mockProjectPath);
+
+        expect(result.framework.type).toBeNull();
+        expect(result.framework.confidence).toBe(0);
+      });
+
+      it('detects Next.js framework', () => {
+        fs.existsSync.mockImplementation((p) => {
+          if (p === path.join(mockProjectPath, 'package.json')) return true;
+          return false;
+        });
+        fs.readFileSync.mockReturnValue(JSON.stringify({
+          dependencies: { next: '^14.0.0' },
+        }));
+
+        const result = ProjectDetector.detect(mockProjectPath);
+
+        expect(result.framework.type).toBe('nextjs');
+        expect(result.framework.confidence).toBeGreaterThan(0.8);
+      });
+
+      it('includes supported features for detected framework', () => {
+        fs.existsSync.mockImplementation((p) => {
+          if (p === path.join(mockProjectPath, 'package.json')) return true;
+          return false;
+        });
+        fs.readFileSync.mockReturnValue(JSON.stringify({
+          dependencies: { next: '^14.0.0' },
+        }));
+
+        const result = ProjectDetector.detect(mockProjectPath);
+
+        expect(result.framework.supportedFeatures).toHaveProperty('oauth');
+        expect(result.framework.supportedFeatures).toHaveProperty('stripe');
+      });
+
+      it('includes available generators for detected framework', () => {
+        fs.existsSync.mockImplementation((p) => {
+          if (p === path.join(mockProjectPath, 'package.json')) return true;
+          return false;
+        });
+        fs.readFileSync.mockReturnValue(JSON.stringify({
+          dependencies: { next: '^14.0.0' },
+        }));
+
+        const result = ProjectDetector.detect(mockProjectPath);
+
+        expect(Array.isArray(result.framework.availableGenerators)).toBe(true);
+        expect(result.framework.availableGenerators).toContain('api-client');
+      });
+
+      it('returns empty features/generators when no framework detected', () => {
+        const result = ProjectDetector.detect(mockProjectPath);
+
+        expect(result.framework.supportedFeatures).toEqual({});
+        expect(result.framework.availableGenerators).toEqual([]);
+      });
+    });
+
+    describe('github detection', () => {
+      it('detects GitHub repository info', () => {
+        fs.existsSync.mockImplementation((p) =>
+          p === path.join(mockProjectPath, '.git')
+        );
+        execSync
+          .mockReturnValueOnce('https://github.com/owner/repo.git\n')
+          .mockReturnValueOnce('main\n');
+
+        const result = ProjectDetector.detect(mockProjectPath);
+
+        expect(result.github.isGitHub).toBe(true);
+        expect(result.github.owner).toBe('owner');
+        expect(result.github.repo).toBe('repo');
+      });
+
+      it('returns github info even without GitHub remote', () => {
+        const result = ProjectDetector.detect(mockProjectPath);
+
+        expect(result.github).toHaveProperty('hasGit');
+        expect(result.github).toHaveProperty('isGitHub');
+      });
+    });
+
+    describe('apiClient detection', () => {
+      it('detects existing API client', () => {
+        fs.existsSync.mockImplementation((p) =>
+          p === path.join(mockProjectPath, 'lib/api-client.ts')
+        );
+        fs.readFileSync.mockReturnValue('import axios');
+
+        const result = ProjectDetector.detect(mockProjectPath);
+
+        expect(result.apiClient.hasApiClient).toBe(true);
+        expect(result.apiClient.clientType).toBe('axios');
+      });
+
+      it('returns apiClient info even without existing client', () => {
+        const result = ProjectDetector.detect(mockProjectPath);
+
+        expect(result.apiClient).toHaveProperty('hasApiClient');
+        expect(result.apiClient).toHaveProperty('clientPath');
+      });
+    });
+
+    describe('oauth detection', () => {
+      it('detects OAuth setup', () => {
+        fs.existsSync.mockImplementation((p) =>
+          p === path.join(mockProjectPath, 'app/api/auth/[...nextauth]/route.ts')
+        );
+        fs.readFileSync.mockReturnValue('GoogleProvider');
+
+        const result = ProjectDetector.detect(mockProjectPath);
+
+        expect(result.oauth.hasOAuth).toBe(true);
+        expect(result.oauth.providers).toContain('google');
+      });
+
+      it('returns oauth info even without existing setup', () => {
+        const result = ProjectDetector.detect(mockProjectPath);
+
+        expect(result.oauth).toHaveProperty('hasOAuth');
+        expect(result.oauth).toHaveProperty('providers');
+      });
+    });
+
+    describe('raw results', () => {
+      it('includes raw framework detection results', () => {
+        const result = ProjectDetector.detect(mockProjectPath);
+
+        expect(result._raw).toHaveProperty('frameworkResults');
+        expect(Array.isArray(result._raw.frameworkResults)).toBe(true);
+      });
+    });
+  });
+
+  describe('getDetector', () => {
+    it('returns detector by type name', () => {
+      const detector = ProjectDetector.getDetector('nextjs');
+
+      expect(detector).not.toBeNull();
+      expect(detector.name).toBe('nextjs');
+    });
+
+    it('returns null for unknown type', () => {
+      const detector = ProjectDetector.getDetector('unknown');
+
+      expect(detector).toBeNull();
+    });
+  });
+
+  describe('getAvailableTypes', () => {
+    it('returns array of detector names', () => {
+      const types = ProjectDetector.getAvailableTypes();
+
+      expect(Array.isArray(types)).toBe(true);
+      expect(types).toContain('nextjs');
+    });
+
+    it('returns strings only', () => {
+      const types = ProjectDetector.getAvailableTypes();
+
+      types.forEach((type) => {
+        expect(typeof type).toBe('string');
+      });
+    });
+  });
+});