@l4yercak3/cli 1.2.21 → 1.3.1

package/src/utils/init-helpers.js

@@ -0,0 +1,243 @@
+/**
+ * Init Helpers
+ * Shared helper functions for project initialization, connection, and sync commands
+ * Extracted from spread.js for reuse across connect.js, scaffold.js, sync.js
+ */
+
+const { execSync } = require('child_process');
+const inquirer = require('inquirer');
+const chalk = require('chalk');
+const backendClient = require('../api/backend-client');
+
+/**
+ * Create an organization on the platform
+ * @param {string} orgName - Organization name
+ * @returns {Promise<{organizationId: string, organizationName: string}>}
+ */
+async function createOrganization(orgName) {
+  console.log(chalk.gray(`  Creating organization "${orgName}"...`));
+  const newOrg = await backendClient.createOrganization(orgName);
+  const organizationId = newOrg.organizationId || newOrg.id || newOrg.data?.organizationId || newOrg.data?.id;
+  const organizationName = newOrg.name || orgName;
+
+  if (!organizationId) {
+    throw new Error('Organization ID not found in response. Please check backend API endpoint.');
+  }
+
+  console.log(chalk.green(`  ✅ Organization created: ${organizationName}\n`));
+  return { organizationId, organizationName };
+}
+
+/**
+ * Generate a new API key for an organization
+ * @param {string} organizationId
+ * @returns {Promise<string>} The API key
+ */
+async function generateNewApiKey(organizationId) {
+  console.log(chalk.gray('  Generating API key...'));
+  const apiKeyResponse = await backendClient.generateApiKey(
+    organizationId,
+    'CLI Generated Key',
+    ['*']
+  );
+  const apiKey = apiKeyResponse.key || apiKeyResponse.apiKey || apiKeyResponse.data?.key || apiKeyResponse.data?.apiKey;
+
+  if (!apiKey) {
+    throw new Error('API key not found in response. Please check backend API endpoint.');
+  }
+
+  console.log(chalk.green(`  ✅ API key generated\n`));
+  return apiKey;
+}
+
+/**
+ * Check if the project is a git repository
+ * @param {string} projectPath
+ * @returns {boolean}
+ */
+function isGitRepo(projectPath) {
+  try {
+    execSync('git rev-parse --is-inside-work-tree', {
+      cwd: projectPath,
+      stdio: 'pipe',
+    });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Get git status (uncommitted changes)
+ * @param {string} projectPath
+ * @returns {string}
+ */
+function getGitStatus(projectPath) {
+  try {
+    const status = execSync('git status --porcelain', {
+      cwd: projectPath,
+      encoding: 'utf8',
+    });
+    return status.trim();
+  } catch {
+    return '';
+  }
+}
+
+/**
+ * Check for uncommitted changes and prompt user to commit first
+ * @param {string} projectPath
+ * @returns {Promise<boolean>} true if should proceed, false to abort
+ */
+async function checkGitStatusBeforeGeneration(projectPath) {
+  const debug = process.env.L4YERCAK3_DEBUG;
+
+  if (debug) {
+    console.log('\n[DEBUG] Git status check:');
+    console.log(`  projectPath: "${projectPath}"`);
+  }
+
+  if (!isGitRepo(projectPath)) {
+    if (debug) console.log('  → Not a git repo, skipping check');
+    return true;
+  }
+
+  const status = getGitStatus(projectPath);
+
+  if (debug) {
+    console.log(`  → Git status: "${status.substring(0, 100)}${status.length > 100 ? '...' : ''}"`);
+  }
+
+  if (!status) {
+    if (debug) console.log('  → No uncommitted changes, proceeding');
+    return true;
+  }
+
+  const changes = status.split('\n').filter(line => line.trim());
+  const modifiedCount = changes.filter(line => line.startsWith(' M') || line.startsWith('M ')).length;
+  const untrackedCount = changes.filter(line => line.startsWith('??')).length;
+  const stagedCount = changes.filter(line => /^[MADRC]/.test(line)).length;
+
+  console.log(chalk.yellow('  ⚠️  Uncommitted changes detected\n'));
+
+  if (modifiedCount > 0) console.log(chalk.gray(`     ${modifiedCount} modified file(s)`));
+  if (untrackedCount > 0) console.log(chalk.gray(`     ${untrackedCount} untracked file(s)`));
+  if (stagedCount > 0) console.log(chalk.gray(`     ${stagedCount} staged file(s)`));
+
+  console.log('');
+  console.log(chalk.gray('  We recommend committing your changes before generating'));
+  console.log(chalk.gray('  new files, so you can easily revert if needed.\n'));
+
+  const { action } = await inquirer.prompt([
+    {
+      type: 'list',
+      name: 'action',
+      message: 'How would you like to proceed?',
+      choices: [
+        { name: 'Continue anyway - I\'ll handle it later', value: 'continue' },
+        { name: 'Commit changes now - Create a checkpoint commit', value: 'commit' },
+        { name: 'Abort - I\'ll commit manually first', value: 'abort' },
+      ],
+    },
+  ]);
+
+  if (action === 'abort') {
+    console.log(chalk.gray('\n  No worries! Run the command again after committing.\n'));
+    return false;
+  }
+
+  if (action === 'commit') {
+    try {
+      execSync('git add -A', { cwd: projectPath, stdio: 'pipe' });
+      const commitMessage = 'chore: checkpoint before L4YERCAK3 integration';
+      execSync(`git commit -m "${commitMessage}"`, { cwd: projectPath, stdio: 'pipe' });
+
+      console.log(chalk.green('\n  ✅ Changes committed successfully'));
+      console.log(chalk.gray(`     Message: "${commitMessage}"`));
+      console.log(chalk.gray('     You can revert with: git reset --soft HEAD~1\n'));
+    } catch (error) {
+      console.log(chalk.yellow('\n  ⚠️  Could not create commit automatically'));
+      console.log(chalk.gray(`     ${error.message}`));
+      console.log(chalk.gray('     Proceeding with file generation anyway...\n'));
+    }
+  }
+
+  return true;
+}
+
+/**
+ * Select or create an organization
+ * @returns {Promise<{organizationId: string, organizationName: string}>}
+ */
+async function selectOrganization(defaultName) {
+  const orgsResponse = await backendClient.getOrganizations();
+  const organizations = Array.isArray(orgsResponse)
+    ? orgsResponse
+    : orgsResponse.organizations || orgsResponse.data || [];
+
+  if (organizations.length === 0) {
+    const { orgName } = await inquirer.prompt([
+      {
+        type: 'input',
+        name: 'orgName',
+        message: 'Organization name:',
+        default: defaultName || 'My Organization',
+        validate: (input) => input.trim().length > 0 || 'Organization name is required',
+      },
+    ]);
+    return createOrganization(orgName);
+  }
+
+  const { orgChoice } = await inquirer.prompt([
+    {
+      type: 'list',
+      name: 'orgChoice',
+      message: 'Select organization:',
+      choices: [
+        ...organizations.map(org => ({
+          name: `${org.name} (${org.id})`,
+          value: org.id,
+        })),
+        { name: '➕ Create new organization', value: '__create__' },
+      ],
+    },
+  ]);
+
+  if (orgChoice === '__create__') {
+    const { orgName } = await inquirer.prompt([
+      {
+        type: 'input',
+        name: 'orgName',
+        message: 'Organization name:',
+        default: defaultName || 'My Organization',
+        validate: (input) => input.trim().length > 0 || 'Organization name is required',
+      },
+    ]);
+    return createOrganization(orgName);
+  }
+
+  const selectedOrg = organizations.find(org => org.id === orgChoice);
+  console.log(chalk.green(`  ✅ Selected organization: ${selectedOrg.name}\n`));
+  return { organizationId: orgChoice, organizationName: selectedOrg.name };
+}
+
+/**
+ * Require the user to be logged in, exit if not
+ */
+function requireAuth(configManager) {
+  if (!configManager.isLoggedIn()) {
+    console.log(chalk.yellow('  ⚠️  You must be logged in first'));
+    console.log(chalk.gray('\n  Run "l4yercak3 login" to authenticate\n'));
+    process.exit(1);
+  }
+}
+
+module.exports = {
+  createOrganization,
+  generateNewApiKey,
+  isGitRepo,
+  getGitStatus,
+  checkGitStatusBeforeGeneration,
+  selectOrganization,
+  requireAuth,
+};

package/tests/page-detector.test.js

@@ -0,0 +1,371 @@
+/**
+ * Page Detector Tests
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+// Mock fs module
+jest.mock('fs');
+
+const pageDetector = require('../src/detectors/page-detector');
+
+describe('PageDetector', () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  describe('Next.js App Router', () => {
+    it('detects pages in app directory', () => {
+      const projectPath = '/test/project';
+
+      // Mock directory structure
+      fs.existsSync.mockImplementation((p) => {
+        const validPaths = [
+          path.join(projectPath, 'app'),
+          path.join(projectPath, 'app', 'page.tsx'),
+          path.join(projectPath, 'app', 'about'),
+          path.join(projectPath, 'app', 'about', 'page.tsx'),
+          path.join(projectPath, 'app', 'dashboard'),
+          path.join(projectPath, 'app', 'dashboard', 'page.tsx'),
+          path.join(projectPath, 'app', 'dashboard', '[id]'),
+          path.join(projectPath, 'app', 'dashboard', '[id]', 'page.tsx'),
+        ];
+        return validPaths.includes(p);
+      });
+
+      fs.readdirSync.mockImplementation((dir) => {
+        if (dir === path.join(projectPath, 'app')) {
+          return [
+            { name: 'page.tsx', isDirectory: () => false, isFile: () => true },
+            { name: 'about', isDirectory: () => true, isFile: () => false },
+            { name: 'dashboard', isDirectory: () => true, isFile: () => false },
+          ];
+        }
+        if (dir === path.join(projectPath, 'app', 'about')) {
+          return [
+            { name: 'page.tsx', isDirectory: () => false, isFile: () => true },
+          ];
+        }
+        if (dir === path.join(projectPath, 'app', 'dashboard')) {
+          return [
+            { name: 'page.tsx', isDirectory: () => false, isFile: () => true },
+            { name: '[id]', isDirectory: () => true, isFile: () => false },
+          ];
+        }
+        if (dir === path.join(projectPath, 'app', 'dashboard', '[id]')) {
+          return [
+            { name: 'page.tsx', isDirectory: () => false, isFile: () => true },
+          ];
+        }
+        return [];
+      });
+
+      const pages = pageDetector.detect(projectPath, 'nextjs', { routerType: 'app' });
+
+      expect(pages).toHaveLength(4);
+      expect(pages).toContainEqual(expect.objectContaining({
+        path: '/',
+        name: 'Home',
+        pageType: 'static',
+      }));
+      expect(pages).toContainEqual(expect.objectContaining({
+        path: '/about',
+        name: 'About',
+        pageType: 'static',
+      }));
+      expect(pages).toContainEqual(expect.objectContaining({
+        path: '/dashboard',
+        name: 'Dashboard',
+        pageType: 'static',
+      }));
+      expect(pages).toContainEqual(expect.objectContaining({
+        path: '/dashboard/[id]',
+        name: 'Dashboard Detail',
+        pageType: 'dynamic',
+      }));
+    });
+
+    it('detects API routes', () => {
+      const projectPath = '/test/project';
+
+      fs.existsSync.mockImplementation((p) => {
+        const validPaths = [
+          path.join(projectPath, 'app'),
+          path.join(projectPath, 'app', 'api'),
+          path.join(projectPath, 'app', 'api', 'users'),
+          path.join(projectPath, 'app', 'api', 'users', 'route.ts'),
+        ];
+        return validPaths.includes(p);
+      });
+
+      fs.readdirSync.mockImplementation((dir) => {
+        if (dir === path.join(projectPath, 'app')) {
+          return [
+            { name: 'api', isDirectory: () => true, isFile: () => false },
+          ];
+        }
+        if (dir === path.join(projectPath, 'app', 'api')) {
+          return [
+            { name: 'users', isDirectory: () => true, isFile: () => false },
+          ];
+        }
+        if (dir === path.join(projectPath, 'app', 'api', 'users')) {
+          return [
+            { name: 'route.ts', isDirectory: () => false, isFile: () => true },
+          ];
+        }
+        return [];
+      });
+
+      const pages = pageDetector.detect(projectPath, 'nextjs', { routerType: 'app' });
+
+      expect(pages).toHaveLength(1);
+      expect(pages[0]).toMatchObject({
+        path: '/api/users',
+        name: 'API: Users',
+        pageType: 'api_route',
+      });
+    });
+
+    it('skips route groups but preserves children', () => {
+      const projectPath = '/test/project';
+
+      fs.existsSync.mockImplementation((p) => {
+        const validPaths = [
+          path.join(projectPath, 'app'),
+          path.join(projectPath, 'app', '(auth)'),
+          path.join(projectPath, 'app', '(auth)', 'login'),
+          path.join(projectPath, 'app', '(auth)', 'login', 'page.tsx'),
+        ];
+        return validPaths.includes(p);
+      });
+
+      fs.readdirSync.mockImplementation((dir) => {
+        if (dir === path.join(projectPath, 'app')) {
+          return [
+            { name: '(auth)', isDirectory: () => true, isFile: () => false },
+          ];
+        }
+        if (dir === path.join(projectPath, 'app', '(auth)')) {
+          return [
+            { name: 'login', isDirectory: () => true, isFile: () => false },
+          ];
+        }
+        if (dir === path.join(projectPath, 'app', '(auth)', 'login')) {
+          return [
+            { name: 'page.tsx', isDirectory: () => false, isFile: () => true },
+          ];
+        }
+        return [];
+      });
+
+      const pages = pageDetector.detect(projectPath, 'nextjs', { routerType: 'app' });
+
+      expect(pages).toHaveLength(1);
+      // Route group (auth) is stripped from path
+      expect(pages[0].path).toBe('/login');
+    });
+  });
+
+  describe('Next.js Pages Router', () => {
+    it('detects pages in pages directory', () => {
+      const projectPath = '/test/project';
+
+      fs.existsSync.mockImplementation((p) => {
+        const validPaths = [
+          path.join(projectPath, 'pages'),
+        ];
+        return validPaths.includes(p);
+      });
+
+      fs.readdirSync.mockImplementation((dir) => {
+        if (dir === path.join(projectPath, 'pages')) {
+          return [
+            { name: 'index.tsx', isDirectory: () => false, isFile: () => true },
+            { name: 'about.tsx', isDirectory: () => false, isFile: () => true },
+            { name: '[slug].tsx', isDirectory: () => false, isFile: () => true },
+            { name: '_app.tsx', isDirectory: () => false, isFile: () => true },
+          ];
+        }
+        return [];
+      });
+
+      const pages = pageDetector.detect(projectPath, 'nextjs', { routerType: 'pages' });
+
+      expect(pages).toHaveLength(3); // Excludes _app.tsx
+      expect(pages).toContainEqual(expect.objectContaining({
+        path: '/',
+        name: 'Home',
+        pageType: 'static',
+      }));
+      expect(pages).toContainEqual(expect.objectContaining({
+        path: '/about',
+        name: 'About',
+        pageType: 'static',
+      }));
+      expect(pages).toContainEqual(expect.objectContaining({
+        path: '/[slug]',
+        name: 'Detail',
+        pageType: 'dynamic',
+      }));
+    });
+
+    it('detects API routes in pages/api', () => {
+      const projectPath = '/test/project';
+
+      fs.existsSync.mockImplementation((p) => {
+        return p === path.join(projectPath, 'pages');
+      });
+
+      fs.readdirSync.mockImplementation((dir) => {
+        if (dir === path.join(projectPath, 'pages')) {
+          return [
+            { name: 'api', isDirectory: () => true, isFile: () => false },
+          ];
+        }
+        if (dir === path.join(projectPath, 'pages', 'api')) {
+          return [
+            { name: 'hello.ts', isDirectory: () => false, isFile: () => true },
+          ];
+        }
+        return [];
+      });
+
+      const pages = pageDetector.detect(projectPath, 'nextjs', { routerType: 'pages' });
+
+      expect(pages).toHaveLength(1);
+      expect(pages[0]).toMatchObject({
+        path: '/api/hello',
+        name: 'API: Hello',
+        pageType: 'api_route',
+      });
+    });
+  });
+
+  describe('Expo Router', () => {
+    it('detects screens in expo-router app directory', () => {
+      const projectPath = '/test/project';
+
+      fs.existsSync.mockImplementation((p) => {
+        const validPaths = [
+          path.join(projectPath, 'app'),
+        ];
+        return validPaths.includes(p);
+      });
+
+      fs.readdirSync.mockImplementation((dir) => {
+        if (dir === path.join(projectPath, 'app')) {
+          return [
+            { name: 'index.tsx', isDirectory: () => false, isFile: () => true },
+            { name: 'profile.tsx', isDirectory: () => false, isFile: () => true },
+            { name: '[id].tsx', isDirectory: () => false, isFile: () => true },
+            { name: '_layout.tsx', isDirectory: () => false, isFile: () => true },
+            { name: '+not-found.tsx', isDirectory: () => false, isFile: () => true },
+          ];
+        }
+        return [];
+      });
+
+      const screens = pageDetector.detect(projectPath, 'expo', { routerType: 'expo-router' });
+
+      expect(screens).toHaveLength(4); // Excludes _layout.tsx
+      expect(screens).toContainEqual(expect.objectContaining({
+        path: '/',
+        name: 'Home',
+        pageType: 'static',
+      }));
+      expect(screens).toContainEqual(expect.objectContaining({
+        path: '/profile',
+        name: 'Profile',
+        pageType: 'static',
+      }));
+      expect(screens).toContainEqual(expect.objectContaining({
+        path: '/[id]',
+        name: 'Detail',
+        pageType: 'dynamic',
+      }));
+      expect(screens).toContainEqual(expect.objectContaining({
+        path: '/*',
+        name: 'Not Found',
+        pageType: 'static',
+      }));
+    });
+  });
+
+  describe('React Navigation', () => {
+    it('detects screens in screens directory', () => {
+      const projectPath = '/test/project';
+
+      fs.existsSync.mockImplementation((p) => {
+        const validPaths = [
+          path.join(projectPath, 'src', 'screens'),
+        ];
+        return validPaths.includes(p);
+      });
+
+      fs.readdirSync.mockImplementation((dir) => {
+        if (dir === path.join(projectPath, 'src', 'screens')) {
+          return [
+            { name: 'HomeScreen.tsx', isDirectory: () => false, isFile: () => true },
+            { name: 'ProfileScreen.tsx', isDirectory: () => false, isFile: () => true },
+            { name: 'SettingsScreen.tsx', isDirectory: () => false, isFile: () => true },
+            { name: 'index.ts', isDirectory: () => false, isFile: () => true },
+          ];
+        }
+        return [];
+      });
+
+      const screens = pageDetector.detect(projectPath, 'expo', { routerType: 'react-navigation' });
+
+      expect(screens).toHaveLength(3); // Excludes index.ts
+      expect(screens).toContainEqual(expect.objectContaining({
+        path: '/',
+        name: 'Home',
+        pageType: 'static',
+      }));
+      expect(screens).toContainEqual(expect.objectContaining({
+        path: '/profile',
+        name: 'Profile',
+        pageType: 'static',
+      }));
+      expect(screens).toContainEqual(expect.objectContaining({
+        path: '/settings',
+        name: 'Settings',
+        pageType: 'static',
+      }));
+    });
+  });
+
+  describe('Page name generation', () => {
+    it('generates correct names for various paths', () => {
+      expect(pageDetector.generatePageName('/')).toBe('Home');
+      expect(pageDetector.generatePageName('/about')).toBe('About');
+      expect(pageDetector.generatePageName('/user-profile')).toBe('User Profile');
+      expect(pageDetector.generatePageName('/dashboard/[id]')).toBe('Dashboard Detail');
+      expect(pageDetector.generatePageName('/api/users', true)).toBe('API: Users');
+      expect(pageDetector.generatePageName('/api', true)).toBe('API: Root');
+    });
+  });
+
+  describe('Page type detection', () => {
+    it('detects dynamic pages', () => {
+      expect(pageDetector.detectPageType('/dashboard/[id]')).toBe('dynamic');
+      expect(pageDetector.detectPageType('/blog/[...slug]')).toBe('dynamic');
+      expect(pageDetector.detectPageType('/users/[userId]/posts/[postId]')).toBe('dynamic');
+    });
+
+    it('detects static pages', () => {
+      expect(pageDetector.detectPageType('/')).toBe('static');
+      expect(pageDetector.detectPageType('/about')).toBe('static');
+      expect(pageDetector.detectPageType('/dashboard')).toBe('static');
+    });
+  });
+
+  describe('Unknown framework', () => {
+    it('returns empty array for unknown framework', () => {
+      const pages = pageDetector.detect('/test/project', 'unknown', {});
+      expect(pages).toEqual([]);
+    });
+  });
+});