@nexical/cli 0.11.10 → 0.11.14

package/src/commands/setup.ts

@@ -6,16 +6,8 @@ export default class SetupCommand extends BaseCommand {
   static description = 'Setup the application environment by symlinking core assets.';
 
   async run() {
-    // We assume we are in the project root
-    // But the CLI might be run from anywhere?
-    // findProjectRoot in index.ts handles finding the root.
-    // BaseCommand has this.projectRoot?
-
-    // BaseCommand doesn't expose projectRoot directly in current implementation seen in memory, checking source if possible?
-    // InitCommand used process.cwd().
-
-    // Let's assume process.cwd() is project root if run via `npm run setup` from root.
-    const rootDir = process.cwd();
+    // Use projectRoot from BaseCommand if available, fallback to cwd
+    const rootDir = this.projectRoot || process.cwd();
 
     // Verify we are in the right place
     if (!fs.existsSync(path.join(rootDir, 'core'))) {
@@ -56,13 +48,14 @@ export default class SetupCommand extends BaseCommand {
             fs.lstatSync(dest);
             fs.removeSync(dest);
           } catch (e: unknown) {
-            if (
+            const isEnoent =
               e &&
               typeof e === 'object' &&
               'code' in e &&
-              (e as { code: string }).code !== 'ENOENT'
-            )
+              (e as { code: string }).code === 'ENOENT';
+            if (!isEnoent) {
               throw e;
+            }
           }
 
           const relSource = path.relative(destDir, source);

package/src/utils/git.ts

@@ -10,8 +10,27 @@ export async function clone(
   options: { recursive?: boolean; depth?: number } = {},
 ): Promise<void> {
   const { recursive = false, depth } = options;
-  const cmd = `git clone ${recursive ? '--recursive ' : ''}${depth ? `--depth ${depth} ` : ''}${url} .`;
-  logger.debug(`Git clone: ${url} to ${destination}`);
+  const args = `${recursive ? '--recursive ' : ''}${depth ? `--depth ${depth} ` : ''}${url} .`;
+
+  // Attempt 1: Anonymous (no credentials)
+  // We use execAsync directly here to handle the error silently if it fails due to auth
+  try {
+    const cmd = `git -c credential.helper= clone ${args}`;
+    logger.debug(`Git clone (anonymous): ${url} to ${destination}`);
+    const { stdout } = await execAsync(cmd, { cwd: destination });
+    if (stdout) {
+      console.log(stdout);
+    }
+    return;
+  } catch (e) {
+    logger.debug(
+      `Anonymous clone failed (${e instanceof Error ? e.message : String(e)}), retrying with default credentials...`,
+    );
+  }
+
+  // Attempt 2: Default (Authenticated or whatever is configured)
+  const cmd = `git clone ${args}`;
+  logger.debug(`Git clone (authenticated): ${url} to ${destination}`);
   await runCommand(cmd, destination);
 }
 
@@ -33,6 +52,28 @@ export async function updateSubmodules(cwd: string): Promise<void> {
   );
 }
 
+export async function addSubmodule(url: string, path: string, cwd: string): Promise<void> {
+  // Attempt 1: Anonymous
+  try {
+    const cmd = `git -c credential.helper= submodule add ${url} ${path}`;
+    logger.debug(`Git submodule add (anonymous): ${url} to ${path}`);
+    const { stdout } = await execAsync(cmd, { cwd });
+    if (stdout) {
+      console.log(stdout);
+    }
+    return;
+  } catch (e) {
+    logger.debug(
+      `Anonymous submodule add failed (${e instanceof Error ? e.message : String(e)}), retrying with default credentials...`,
+    );
+  }
+
+  // Attempt 2: Default
+  const cmd = `git submodule add ${url} ${path}`;
+  logger.debug(`Git submodule add (authenticated): ${url} to ${path}`);
+  await runCommand(cmd, cwd);
+}
+
 export async function checkoutOrphan(branch: string, cwd: string): Promise<void> {
   await runCommand(`git checkout --orphan ${branch}`, cwd);
 }

package/test/e2e/lifecycle.e2e.test.ts

@@ -65,16 +65,17 @@ if (args[0] === 'build') {
         },
       }),
       'README.md': '# E2E Starter',
-      'nexical.yml': 'name: e2e-test\nversion: 0.0.1', // ESSENTIAL for CLI to recognize project
-      'src/pages/index.astro': '--- ---',
-      'src/core/index.ts': '// core',
-      'src/core/package.json': JSON.stringify({
+      'nexical.yaml': 'name: e2e-test\nversion: 0.0.1', // ESSENTIAL for CLI to recognize project
+      'core/src/index.ts': '// core',
+      'core/package.json': JSON.stringify({
         scripts: {
           build: 'astro build',
           dev: 'astro dev',
           preview: 'astro preview',
         },
       }),
+      'apps/frontend/package.json': '{}',
+      'apps/backend/package.json': '{}',
     });
 
     // 3. Setup Mock Module Repo

package/test/integration/commands/init.integration.test.ts

@@ -27,6 +27,9 @@ describe('InitCommand Integration', () => {
         },
       }),
       'README.md': '# Starter Template',
+      'core/src/index.ts': 'console.log("core")',
+      'apps/frontend/README.md': '# Frontend',
+      'apps/backend/README.md': '# Backend',
     });
 
     // Set Git Identity for the test process so InitCommand's commit works in CI

package/test/unit/commands/deploy.test.ts

@@ -257,6 +257,32 @@ describe('DeployCommand', () => {
     await expect(command.run({})).rejects.toThrow('CLI ERROR');
   });
 
+  it('should handle non-Error exceptions during frontend secret resolution', async () => {
+    const mockBackend = {
+      name: 'railway',
+      provision: vi.fn(),
+      getSecrets: vi.fn().mockResolvedValue({}),
+      getVariables: vi.fn().mockResolvedValue({}),
+    };
+    const mockFrontend = {
+      name: 'cloudflare',
+      provision: vi.fn(),
+      getSecrets: vi.fn().mockRejectedValue('String front secret fail'),
+      getVariables: vi.fn().mockResolvedValue({}),
+    };
+    mockRegistry.getDeploymentProvider.mockImplementation((name: string) => {
+      if (name === 'railway') return mockBackend;
+      if (name === 'cloudflare') return mockFrontend;
+    });
+    mockRegistry.getRepositoryProvider.mockReturnValue({
+      configureSecrets: vi.fn(),
+      configureVariables: vi.fn(),
+      generateWorkflow: vi.fn(),
+    });
+
+    await expect(command.run({})).rejects.toThrow('CLI ERROR');
+  });
+
   it('should handle errors during frontend variable resolution', async () => {
     const mockBackend = {
       name: 'railway',
@@ -282,4 +308,48 @@ describe('DeployCommand', () => {
 
     await expect(command.run({})).rejects.toThrow('CLI ERROR');
   });
+
+  it('should handle non-Error exceptions during frontend variable resolution', async () => {
+    const mockBackend = {
+      name: 'railway',
+      provision: vi.fn(),
+      getSecrets: vi.fn().mockResolvedValue({}),
+      getVariables: vi.fn().mockResolvedValue({}),
+    };
+    const mockFrontend = {
+      name: 'cloudflare',
+      provision: vi.fn(),
+      getSecrets: vi.fn().mockResolvedValue({}),
+      getVariables: vi.fn().mockRejectedValue('String front var fail'),
+    };
+    mockRegistry.getDeploymentProvider.mockImplementation((name: string) => {
+      if (name === 'railway') return mockBackend;
+      if (name === 'cloudflare') return mockFrontend;
+    });
+    mockRegistry.getRepositoryProvider.mockReturnValue({
+      configureSecrets: vi.fn(),
+      configureVariables: vi.fn(),
+      generateWorkflow: vi.fn(),
+    });
+
+    await expect(command.run({})).rejects.toThrow('CLI ERROR');
+  });
+
+  it('should throw if frontend provider is not found in registry', async () => {
+    mockRegistry.getDeploymentProvider.mockImplementation((name: string) => {
+      if (name === 'railway') return { name: 'railway' };
+      return undefined;
+    });
+    await expect(command.run({ frontend: 'unknown' })).rejects.toThrow(
+      "Frontend provider 'unknown' not found.",
+    );
+  });
+
+  it('should throw if repo provider is not found in registry', async () => {
+    mockRegistry.getDeploymentProvider.mockReturnValue({ name: 'mock' });
+    mockRegistry.getRepositoryProvider.mockReturnValue(undefined);
+    await expect(command.run({ repo: 'unknown' })).rejects.toThrow(
+      "Repository provider 'unknown' not found.",
+    );
+  });
 });

package/test/unit/commands/init.test.ts

@@ -1,6 +1,7 @@
 import { runCommand } from '@nexical/cli-core';
 import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
 import InitCommand from '../../../src/commands/init.js';
+import SetupCommand from '../../../src/commands/setup.js';
 import * as git from '../../../src/utils/git.js';
 import fs from 'fs-extra';
 
@@ -34,6 +35,15 @@ vi.mock('../../../src/utils/git.js', () => ({
   getRemoteUrl: vi.fn(),
 }));
 
+vi.mock('../../../src/commands/setup.js', () => {
+  const MockSetup = vi.fn();
+  MockSetup.prototype.init = vi.fn();
+  MockSetup.prototype.run = vi.fn();
+  return {
+    default: MockSetup,
+  };
+});
+
 vi.mock('fs-extra');
 
 describe('InitCommand', () => {
@@ -43,7 +53,9 @@ describe('InitCommand', () => {
   beforeEach(() => {
     vi.clearAllMocks();
     command = new InitCommand({});
-    vi.spyOn(command, 'error').mockImplementation(() => {});
+    vi.spyOn(command, 'error').mockImplementation((msg) => {
+      console.error('COMMAND ERROR:', msg);
+    });
     vi.spyOn(command, 'info').mockImplementation(() => {});
     vi.spyOn(command, 'success').mockImplementation(() => {});
 
@@ -111,6 +123,12 @@ describe('InitCommand', () => {
       expect.stringContaining(targetDir),
     );
 
+    // SetupCommand verification
+    expect(SetupCommand).toHaveBeenCalled();
+    const setupInstance = vi.mocked(SetupCommand).mock.instances[0];
+    expect(setupInstance.init).toHaveBeenCalled();
+    expect(setupInstance.run).toHaveBeenCalled();
+
     expect(command.success).toHaveBeenCalledWith(expect.stringContaining('successfully'));
   });
 

package/test/unit/commands/module/add.test.ts

@@ -43,6 +43,7 @@ describe('ModuleAddCommand', () => {
     (fs.remove as unknown as { mockResolvedValue: any }).mockResolvedValue(undefined);
     (fs.writeFile as unknown as { mockResolvedValue: any }).mockResolvedValue(undefined);
     (gitUtils.clone as unknown as { mockResolvedValue: any }).mockResolvedValue(undefined);
+    (gitUtils.addSubmodule as unknown as { mockResolvedValue: any }).mockResolvedValue(undefined);
     (cliCore.runCommand as unknown as { mockResolvedValue: any }).mockResolvedValue(undefined);
   });
 
@@ -69,10 +70,9 @@ describe('ModuleAddCommand', () => {
     await command.run({ url: repoUrl });
 
     expect(gitUtils.clone).toHaveBeenCalled();
-    expect(cliCore.runCommand).toHaveBeenCalledWith(
-      expect.stringContaining(
-        `git submodule add ${repoUrl} apps/backend/modules/my-backend-module`,
-      ),
+    expect(gitUtils.addSubmodule).toHaveBeenCalledWith(
+      repoUrl,
+      'apps/backend/modules/my-backend-module',
       projectRoot,
     );
   });
@@ -95,10 +95,9 @@ describe('ModuleAddCommand', () => {
 
     await command.run({ url: repoUrl });
 
-    expect(cliCore.runCommand).toHaveBeenCalledWith(
-      expect.stringContaining(
-        `git submodule add ${repoUrl} apps/frontend/modules/my-frontend-module`,
-      ),
+    expect(gitUtils.addSubmodule).toHaveBeenCalledWith(
+      repoUrl,
+      'apps/frontend/modules/my-frontend-module',
       projectRoot,
     );
   });
@@ -124,8 +123,9 @@ describe('ModuleAddCommand', () => {
 
     await command.run({ url: repoUrl });
 
-    expect(cliCore.runCommand).toHaveBeenCalledWith(
-      expect.stringContaining('apps/backend/modules/pkg-mod'),
+    expect(gitUtils.addSubmodule).toHaveBeenCalledWith(
+      expect.anything(),
+      'apps/backend/modules/pkg-mod',
       projectRoot,
     );
   });
@@ -142,8 +142,9 @@ describe('ModuleAddCommand', () => {
 
     await command.run({ url: repoUrl });
 
-    expect(cliCore.runCommand).toHaveBeenCalledWith(
-      expect.stringContaining('apps/backend/modules/fallback-mod'),
+    expect(gitUtils.addSubmodule).toHaveBeenCalledWith(
+      expect.anything(),
+      'apps/backend/modules/fallback-mod',
       projectRoot,
     );
   });
@@ -160,8 +161,9 @@ describe('ModuleAddCommand', () => {
 
     await command.run({ url: repoUrl });
 
-    expect(cliCore.runCommand).toHaveBeenCalledWith(
-      expect.stringContaining('apps/frontend/modules/comp-mod'),
+    expect(gitUtils.addSubmodule).toHaveBeenCalledWith(
+      expect.anything(),
+      'apps/frontend/modules/comp-mod',
       projectRoot,
     );
   });
@@ -212,8 +214,16 @@ describe('ModuleAddCommand', () => {
 
     await command.run({ url: rootUrl });
 
-    expect(cliCore.runCommand).toHaveBeenCalledWith(expect.stringContaining('root'), projectRoot);
-    expect(cliCore.runCommand).toHaveBeenCalledWith(expect.stringContaining('dep'), projectRoot);
+    expect(gitUtils.addSubmodule).toHaveBeenCalledWith(
+      expect.stringContaining('root'),
+      expect.anything(),
+      projectRoot,
+    );
+    expect(gitUtils.addSubmodule).toHaveBeenCalledWith(
+      expect.stringContaining('dep'),
+      expect.anything(),
+      projectRoot,
+    );
   });
 
   it('should throw error on dependency conflict', async () => {
@@ -359,8 +369,9 @@ describe('ModuleAddCommand', () => {
     });
 
     await command.run({ url: 'https://github.com/org/yml.git' });
-    expect(cliCore.runCommand).toHaveBeenCalledWith(
-      expect.stringContaining('yml-mod'),
+    expect(gitUtils.addSubmodule).toHaveBeenCalledWith(
+      expect.stringContaining('yml'),
+      'apps/backend/modules/yml-mod',
       projectRoot,
     );
   });
@@ -391,8 +402,9 @@ describe('ModuleAddCommand', () => {
     });
 
     await command.run({ url: 'https://github.com/org/obj.git' });
-    expect(cliCore.runCommand).toHaveBeenCalledWith(
-      expect.stringContaining('dep-mod'),
+    expect(gitUtils.addSubmodule).toHaveBeenCalledWith(
+      expect.stringContaining('dep'),
+      'apps/backend/modules/dep-mod',
       projectRoot,
     );
   });
@@ -435,4 +447,192 @@ describe('ModuleAddCommand', () => {
     expect(writeCall[1]).toContain('backend:');
     expect(writeCall[1]).toContain('new-mod');
   });
+  it('should handle module name from package.json without scope', async () => {
+    const repoUrl = 'https://github.com/org/noscope-repo.git';
+    (fs.pathExists as unknown as { mockImplementation: any }).mockImplementation((p: string) => {
+      const pStr = p.toString();
+      if (pStr.endsWith('package.json')) return true;
+      if (pStr.includes('nexical.yaml')) return true;
+      return false;
+    });
+    (fs.readJson as unknown as { mockResolvedValue: any }).mockResolvedValue({
+      name: 'noscope-mod',
+    });
+    (fs.readFile as unknown as { mockResolvedValue: any }).mockResolvedValue('modules: {}');
+
+    await command.run({ url: repoUrl });
+
+    expect(gitUtils.addSubmodule).toHaveBeenCalledWith(
+      expect.anything(),
+      'apps/backend/modules/noscope-mod',
+      projectRoot,
+    );
+  });
+
+  it('should handle package.json without name', async () => {
+    const repoUrl = 'https://github.com/org/noname-repo.git';
+    (fs.pathExists as unknown as { mockImplementation: any }).mockImplementation((p: string) => {
+      const pStr = p.toString();
+      if (pStr.endsWith('package.json')) return true;
+      if (pStr.includes('nexical.yaml')) return true;
+      return false;
+    });
+    (fs.readJson as unknown as { mockResolvedValue: any }).mockResolvedValue({});
+    (fs.readFile as unknown as { mockResolvedValue: any }).mockResolvedValue('modules: {}');
+
+    await command.run({ url: repoUrl });
+
+    expect(gitUtils.addSubmodule).toHaveBeenCalledWith(
+      expect.anything(),
+      'apps/backend/modules/noname-repo',
+      projectRoot,
+    );
+  });
+
+  it('should skip adding if already in nexical.yaml', async () => {
+    (fs.pathExists as unknown as { mockImplementation: any }).mockImplementation((p: string) => {
+      if (p.includes('nexical.yaml')) return true;
+      if (p.endsWith('module.yaml')) return true;
+      return false;
+    });
+    (fs.readFile as unknown as { mockImplementation: any }).mockImplementation((p: string) => {
+      if (p.includes('nexical.yaml')) return 'modules:\n  backend:\n    - existing';
+      if (p.endsWith('module.yaml')) return 'name: existing\n';
+      return '';
+    });
+
+    await command.run({ url: 'http://example.com/existing.git' });
+
+    expect(fs.writeFile).not.toHaveBeenCalled();
+  });
+  it('should handle missing name in module.yaml', async () => {
+    const repoUrl = 'https://github.com/org/noname-yaml.git';
+    (fs.pathExists as unknown as { mockImplementation: any }).mockImplementation((p: string) => {
+      const pStr = p.toString();
+      if (pStr.endsWith('module.yaml')) return true;
+      if (pStr.includes('nexical.yaml')) return true;
+      return false;
+    });
+    (fs.readFile as unknown as { mockImplementation: any }).mockImplementation((p: string) => {
+      if (p.endsWith('module.yaml')) return 'version: 1.0.0\n'; // name missing
+      if (p.includes('nexical.yaml')) return 'modules: {}';
+      return '';
+    });
+
+    await command.run({ url: repoUrl });
+
+    expect(gitUtils.addSubmodule).toHaveBeenCalledWith(
+      expect.anything(),
+      'apps/backend/modules/noname-yaml',
+      projectRoot,
+    );
+  });
+
+  it('should handle subpath in url', async () => {
+    const repoUrl = 'https://github.com/org/repo.git';
+    const subpath = 'my/sub';
+    (fs.pathExists as unknown as { mockImplementation: any }).mockImplementation((p: string) => {
+      if (p.includes('nexical.yaml')) return true;
+      if (p.endsWith('module.yaml')) return true;
+      return false;
+    });
+    (fs.readFile as unknown as { mockImplementation: any }).mockImplementation((p: string) => {
+      if (p.includes('nexical.yaml')) return 'modules: {}';
+      if (p.endsWith('module.yaml')) return 'name: sub-mod\n';
+      return '';
+    });
+
+    await command.run({ url: `${repoUrl}//${subpath}` });
+
+    expect(gitUtils.clone).toHaveBeenCalledWith(repoUrl, expect.anything(), expect.anything());
+    expect(gitUtils.addSubmodule).toHaveBeenCalledWith(
+      repoUrl,
+      'apps/backend/modules/sub-mod',
+      projectRoot,
+    );
+  });
+  it('should handle url without subpath explicitly', async () => {
+    const repoUrl = 'https://github.com/org/nosub.git';
+    (fs.pathExists as unknown as { mockImplementation: any }).mockImplementation((p: string) => {
+      if (p.includes('nexical.yaml')) return true;
+      if (p.endsWith('module.yaml')) return true;
+      return false;
+    });
+    (fs.readFile as unknown as { mockImplementation: any }).mockImplementation((p: string) => {
+      if (p.includes('nexical.yaml')) return 'modules: {}';
+      if (p.endsWith('module.yaml')) return 'name: nosub-mod\n';
+      return '';
+    });
+
+    await command.run({ url: repoUrl });
+
+    expect(gitUtils.addSubmodule).toHaveBeenCalledWith(
+      repoUrl,
+      'apps/backend/modules/nosub-mod',
+      projectRoot,
+    );
+  });
+  it('should handle dependencies as an object', async () => {
+    const repoUrl = 'https://github.com/org/dep-obj.git';
+
+    // We must ensure that targetDir (apps/backend/modules/dep-obj) does NOT exist for initial call
+    // and ALSO for some-dep if we want to see install logs.
+    (fs.pathExists as any).mockImplementation((p: string) => {
+      const pStr = p.toString();
+      if (pStr.includes('nexical.yaml')) return true;
+      if (pStr.includes('module.yaml')) return true;
+      if (pStr.includes('models.yaml') || pStr.includes('api.yaml')) return true;
+      return false;
+    });
+
+    (fs.readFile as any).mockImplementation((p: string) => {
+      const pStr = p.toString();
+      if (pStr.endsWith('module.yaml')) {
+        if (pStr.includes('staging')) {
+          return 'name: dep-obj\ndependencies:\n  some-dep: "1.0.0"\n';
+        }
+      }
+      if (pStr.includes('nexical.yaml')) return 'modules: {}';
+      return '';
+    });
+
+    await command.run({ url: repoUrl });
+
+    // Check if error was called which might explain failure
+    if ((command.error as any).mock.calls.length > 0) {
+      // eslint-disable-next-line no-console
+      console.log('COMMAND ERROR:', (command.error as any).mock.calls[0][0]);
+    }
+
+    expect(command.info).toHaveBeenCalledWith(expect.stringContaining('Resolving 1 dependencies'));
+  });
+
+  it('should handle already installed module with matching remote', async () => {
+    const repoUrl = 'https://github.com/org/match.git';
+    (fs.pathExists as any).mockImplementation((p: string) => {
+      if (p.includes('apps/backend/modules/match')) return true;
+      return true;
+    });
+    (fs.readFile as any).mockImplementation((p: string) => {
+      if (p.endsWith('module.yaml')) return 'name: match\n';
+      return 'modules: {}';
+    });
+    (gitUtils.getRemoteUrl as any).mockResolvedValue('https://github.com/org/match.git');
+
+    await command.run({ url: repoUrl });
+    expect(command.info).toHaveBeenCalledWith(expect.stringContaining('already installed'));
+  });
+
+  it('should handle already installed module with empty remote', async () => {
+    const repoUrl = 'https://github.com/org/empty-rem.git';
+    (fs.pathExists as any).mockImplementation((p: string) => true);
+    (fs.readFile as any).mockImplementation((p: string) => {
+      if (p.endsWith('module.yaml')) return 'name: empty-rem\n';
+      return 'modules: {}';
+    });
+    (gitUtils.getRemoteUrl as any).mockResolvedValue('');
+
+    await command.run({ url: repoUrl });
+    expect(command.info).toHaveBeenCalledWith(expect.stringContaining('already installed'));
+  });
 });