@nexical/cli 0.1.7 → 0.11.0

package/test/unit/utils/git.test.ts

@@ -0,0 +1,152 @@
+import { runCommand } from '@nexical/cli-core';
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import * as git from '../../../src/utils/git.js';
+
+const mocks = vi.hoisted(() => ({
+    exec: vi.fn(),
+}));
+
+vi.mock('@nexical/cli-core', async (importOriginal) => {
+    const mod = await importOriginal<typeof import('@nexical/cli-core')>();
+    return {
+        ...mod,
+        runCommand: vi.fn(),
+        logger: { code: vi.fn(), debug: vi.fn() }
+    }
+});
+
+vi.mock('node:child_process', () => ({
+    exec: mocks.exec,
+}));
+
+vi.mock('node:util', async () => {
+    const actual = await vi.importActual<any>('node:util');
+    return {
+        ...actual,
+        promisify: (fn: Function) => {
+            return (...args: any[]) => new Promise((resolve, reject) => {
+                fn(...args, (err: Error | null, ...values: any[]) => {
+                    if (err) return reject(err);
+                    // Handle exec-like signature (stdout, stderr) -> { stdout, stderr }
+                    // Simple heuristic: if values.length > 1, assume explicit mapping needed?
+                    // Or just hardcode for our known usage (exec).
+                    if (values.length >= 2) {
+                        resolve({ stdout: values[0], stderr: values[1] });
+                    } else {
+                        resolve(values[0]);
+                    }
+                });
+            });
+        }
+    };
+});
+
+describe('git utils', () => {
+    beforeEach(() => {
+        vi.clearAllMocks();
+    });
+
+    it('should clone repository', async () => {
+        await git.clone('http://repo.git', 'dest', { recursive: true });
+        expect(runCommand).toHaveBeenCalledWith(
+            'git clone --recursive http://repo.git .',
+            'dest'
+        );
+    });
+
+    it('should clone repository with depth', async () => {
+        await git.clone('http://repo.git', 'dest', { depth: 1 });
+        expect(runCommand).toHaveBeenCalledWith(
+            'git clone --depth 1 http://repo.git .',
+            'dest'
+        );
+    });
+
+    it('should update submodules', async () => {
+        await git.updateSubmodules('dest');
+        expect(runCommand).toHaveBeenCalledWith(
+            'git submodule foreach --recursive "git checkout main && git pull origin main"',
+            'dest'
+        );
+    });
+
+    it('should checkout orphan branch', async () => {
+        await git.checkoutOrphan('branch', 'dest');
+        expect(runCommand).toHaveBeenCalledWith('git checkout --orphan branch', 'dest');
+    });
+
+    it('should get remote url', async () => {
+        // Mock exec to call the callback with success
+        mocks.exec.mockImplementation((((cmd: string, options: any, callback: any) => {
+            if (typeof options === 'function') {
+                callback = options;
+                options = {};
+            }
+            // callback(error, stdout, stderr)
+            callback(null, 'https://github.com/origin.git\n', '');
+            return {} as any; // exec returns a ChildProcess
+        }) as any));
+
+        const url = await git.getRemoteUrl('cwd');
+        expect(url).toBe('https://github.com/origin.git');
+        expect(mocks.exec).toHaveBeenCalledWith('git remote get-url origin', { cwd: 'cwd' }, expect.any(Function));
+    });
+
+    it('should return empty string on getRemoteUrl failure', async () => {
+        // Mock exec to call the callback with error
+        mocks.exec.mockImplementation((((cmd: string, options: any, callback: any) => {
+            if (typeof options === 'function') callback = options;
+            callback(new Error('fail'), '', '');
+            return {} as any;
+        }) as any));
+
+        const url = await git.getRemoteUrl('cwd');
+        expect(url).toBe('');
+    });
+});
+
+it('should add all files', async () => {
+    await git.addAll('cwd');
+    expect(runCommand).toHaveBeenCalledWith('git add -A', 'cwd');
+});
+
+it('should commit', async () => {
+    await git.commit('msg', 'cwd');
+    expect(runCommand).toHaveBeenCalledWith('git commit -m "msg"', 'cwd');
+});
+
+it('should delete branch', async () => {
+    await git.deleteBranch('branch', 'cwd');
+    expect(runCommand).toHaveBeenCalledWith('git branch -D branch', 'cwd');
+});
+
+it('should rename branch', async () => {
+    await git.renameBranch('branch', 'cwd');
+    expect(runCommand).toHaveBeenCalledWith('git branch -m branch', 'cwd');
+});
+
+it('should remove remote', async () => {
+    await git.removeRemote('origin', 'cwd');
+    expect(runCommand).toHaveBeenCalledWith('git remote remove origin', 'cwd');
+});
+
+it('should check if branch exists', async () => {
+    // Mock success
+    mocks.exec.mockImplementation((((cmd: string, options: any, callback: any) => {
+        if (typeof options === 'function') callback = options;
+        callback(null, '', '');
+        return {} as any;
+    }) as any));
+
+    expect(await git.branchExists('branch', 'cwd')).toBe(true);
+    expect(mocks.exec).toHaveBeenCalledWith('git show-ref --verify --quiet refs/heads/branch', { cwd: 'cwd' }, expect.any(Function));
+
+    // Mock failure
+    mocks.exec.mockImplementation((((cmd: string, options: any, callback: any) => {
+        if (typeof options === 'function') callback = options;
+        callback(new Error('fail'), '', '');
+        return {} as any;
+    }) as any));
+
+    expect(await git.branchExists('branch', 'cwd')).toBe(false);
+});

package/test/unit/utils/integration-helpers.test.ts

@@ -0,0 +1,72 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import * as helpers from '../../utils/integration-helpers.js';
+import fs from 'fs-extra';
+import { execa } from 'execa';
+import path from 'path';
+
+vi.mock('fs-extra');
+vi.mock('execa');
+
+describe('Integration Helpers Unit', () => {
+    beforeEach(() => {
+        vi.clearAllMocks();
+    });
+
+    it('runCLI should execute node with correct arguments', async () => {
+        vi.mocked(execa).mockResolvedValue({ exitCode: 0 } as any);
+        const args = ['init', 'my-project'];
+        const cwd = '/test/cwd';
+        const env = { FOO: 'bar' };
+
+        await helpers.runCLI(args, cwd, { env });
+
+        expect(execa).toHaveBeenCalledWith(
+            'node',
+            expect.arrayContaining([expect.stringContaining('dist/index.js'), ...args]),
+            expect.objectContaining({
+                cwd,
+                env: expect.objectContaining({ FOO: 'bar' }),
+                reject: false
+            })
+        );
+    });
+
+    it('createTempDir should create directory and return path', async () => {
+        vi.mocked(fs.ensureDir).mockResolvedValue(undefined);
+
+        const dir = await helpers.createTempDir('test-prefix-');
+
+        expect(dir).toContain('test-prefix-');
+        expect(fs.ensureDir).toHaveBeenCalledWith(dir);
+    });
+
+    it('cleanupTestRoot should remove test root directory', async () => {
+        vi.mocked(fs.remove).mockResolvedValue(undefined);
+
+        await helpers.cleanupTestRoot();
+
+        expect(fs.remove).toHaveBeenCalledWith(expect.stringContaining('.test-tmp'));
+    });
+
+    it('createMockRepo should initialize git repo and commit files', async () => {
+        vi.mocked(fs.ensureDir).mockResolvedValue(undefined);
+        vi.mocked(fs.outputFile).mockResolvedValue(undefined);
+        vi.mocked(execa).mockResolvedValue({} as any);
+
+        const dir = '/test/repo';
+        const files = {
+            'package.json': '{}',
+            'README.md': '# Test'
+        };
+
+        await helpers.createMockRepo(dir, files);
+
+        expect(fs.ensureDir).toHaveBeenCalledWith(dir);
+        expect(execa).toHaveBeenCalledWith('git', ['init'], expect.objectContaining({ cwd: dir }));
+        expect(execa).toHaveBeenCalledWith('git', ['config', 'user.email', 'test@test.com'], expect.objectContaining({ cwd: dir }));
+        expect(fs.outputFile).toHaveBeenCalledWith(path.join(dir, 'package.json'), '{}');
+        expect(fs.outputFile).toHaveBeenCalledWith(path.join(dir, 'README.md'), '# Test');
+        expect(execa).toHaveBeenCalledWith('git', ['add', '.'], expect.objectContaining({ cwd: dir }));
+        expect(execa).toHaveBeenCalledWith('git', ['commit', '-m', 'Initial commit'], expect.objectContaining({ cwd: dir }));
+    });
+});

package/test/unit/utils/url-resolver.test.ts

@@ -0,0 +1,39 @@
+import { describe, it, expect } from 'vitest';
+import { resolveGitUrl } from '../../../src/utils/url-resolver';
+
+describe('resolveGitUrl', () => {
+    it('should expand gh@ shorthand correctly', () => {
+        expect(resolveGitUrl('gh@nexical-cms/starter')).toBe('https://github.com/nexical-cms/starter.git');
+    });
+
+    it('should expand gh@ shorthand with subpath correctly', () => {
+        expect(resolveGitUrl('gh@nexical-cms/starter//path/to/module')).toBe('https://github.com/nexical-cms/starter.git//path/to/module');
+    });
+
+    it('should add .git extension to standard URLs if missing', () => {
+        expect(resolveGitUrl('https://github.com/nexical-cms/starter')).toBe('https://github.com/nexical-cms/starter.git');
+    });
+
+    it('should preserve .git extension if already present', () => {
+        expect(resolveGitUrl('https://github.com/nexical-cms/starter.git')).toBe('https://github.com/nexical-cms/starter.git');
+    });
+
+    it('should handle standard URLs with subpath correctly', () => {
+        expect(resolveGitUrl('https://github.com/nexical-cms/starter//path/to/dir')).toBe('https://github.com/nexical-cms/starter.git//path/to/dir');
+    });
+
+    it('should handle standard URLs with .git and subpath correctly', () => {
+        expect(resolveGitUrl('https://github.com/nexical-cms/starter.git//path/to/dir')).toBe('https://github.com/nexical-cms/starter.git//path/to/dir');
+    });
+
+    it('should throw error for empty url', () => {
+        expect(() => resolveGitUrl('')).toThrow('URL cannot be empty');
+    });
+
+    it('should not append .git to local paths', () => {
+        expect(resolveGitUrl('/tmp/local/repo')).toBe('/tmp/local/repo');
+        expect(resolveGitUrl('./local/repo')).toBe('./local/repo');
+        expect(resolveGitUrl('../local/repo')).toBe('../local/repo');
+        expect(resolveGitUrl('file:///tmp/repo')).toBe('file:///tmp/repo');
+    });
+});

package/test/utils/integration-helpers.ts

@@ -0,0 +1,66 @@
+import path from 'node:path';
+import fs from 'fs-extra';
+import { execa } from 'execa';
+import { fileURLToPath } from 'node:url';
+
+// Constants
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+export const TEST_ROOT = path.resolve(__dirname, '../../.test-tmp');
+export const CLI_BIN = path.resolve(__dirname, '../../dist/index.js');
+
+/**
+ * Runs the CLI command against the compiled binary (E2E style)
+ */
+export async function runCLI(args: string[], cwd: string, options: any = {}) {
+    return execa('node', [CLI_BIN, ...args], {
+        cwd,
+        ...options,
+        env: {
+            ...process.env,
+            ...options.env
+        },
+        reject: false // Allow checking exit code in tests
+    });
+}
+
+/**
+ * Creates a temporary directory for testing.
+ * @returns The absolute path to the temporary directory.
+ */
+export async function createTempDir(prefix = 'test-'): Promise<string> {
+    const dir = path.join(TEST_ROOT, `${prefix}${Date.now()}-${Math.random().toString(36).slice(2)}`);
+    await fs.ensureDir(dir);
+    return dir;
+}
+
+/**
+ * Cleans up the temporary test root.
+ */
+export async function cleanupTestRoot(): Promise<void> {
+    await fs.remove(TEST_ROOT);
+}
+
+/**
+ * Creates a mock git repository at the specified path.
+ * This is useful for testing commands that clone from a remote.
+ */
+export async function createMockRepo(dir: string, initialFiles: Record<string, string> = {}): Promise<string> {
+    await fs.ensureDir(dir);
+
+    // Initialize bare repo? No, usually we want a regular repo then commit, 
+    // but if we want to clone FROM it locally, it acts as a remote.
+    // Let's make it a regular repo.
+    await execa('git', ['init'], { cwd: dir });
+    await execa('git', ['config', 'user.email', 'test@test.com'], { cwd: dir });
+    await execa('git', ['config', 'user.name', 'Test User'], { cwd: dir });
+
+    // Write initial files
+    for (const [filename, content] of Object.entries(initialFiles)) {
+        await fs.outputFile(path.join(dir, filename), content);
+    }
+
+    await execa('git', ['add', '.'], { cwd: dir });
+    await execa('git', ['commit', '-m', 'Initial commit'], { cwd: dir });
+
+    return dir;
+}

package/vitest.e2e.config.ts

@@ -6,6 +6,5 @@ export default defineConfig({
         environment: 'node',
         include: ['test/e2e/**/*.test.ts'],
         testTimeout: 60000,
-        fileParallelism: false,
     },
 });

package/dist/chunk-JDRAVUKK.js

@@ -1,48 +0,0 @@
-import { createRequire } from "module"; const require = createRequire(import.meta.url);
-
-// src/utils/nexical-client.ts
-import { NexicalClient } from "@nexical/sdk";
-import fs from "fs";
-import path from "path";
-import os from "os";
-var getConfigPaths = () => {
-  const HOME = process.env.HOME || os.homedir();
-  const CONFIG_DIR = path.join(HOME, ".nexical");
-  const CONFIG_FILE = path.join(CONFIG_DIR, "config.json");
-  return { CONFIG_DIR, CONFIG_FILE };
-};
-function getConfig() {
-  const { CONFIG_FILE } = getConfigPaths();
-  if (!fs.existsSync(CONFIG_FILE)) {
-    return {};
-  }
-  try {
-    const content = fs.readFileSync(CONFIG_FILE, "utf-8");
-    return JSON.parse(content);
-  } catch (error) {
-    return {};
-  }
-}
-function saveToken(token) {
-  const { CONFIG_DIR, CONFIG_FILE } = getConfigPaths();
-  if (!fs.existsSync(CONFIG_DIR)) {
-    fs.mkdirSync(CONFIG_DIR, { recursive: true });
-  }
-  const config = getConfig();
-  config.token = token;
-  fs.writeFileSync(CONFIG_FILE, JSON.stringify(config, null, 2));
-}
-function getClient() {
-  const config = getConfig();
-  return new NexicalClient({
-    token: config.token,
-    baseURL: process.env.NEXICAL_API_URL
-  });
-}
-
-export {
-  getConfig,
-  saveToken,
-  getClient
-};
-//# sourceMappingURL=chunk-JDRAVUKK.js.map

package/dist/chunk-JDRAVUKK.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/utils/nexical-client.ts"],"sourcesContent":["\nimport { NexicalClient } from '@nexical/sdk';\nimport fs from 'node:fs';\nimport path from 'node:path';\nimport os from 'node:os';\n\nconst getConfigPaths = () => {\n    const HOME = process.env.HOME || os.homedir();\n    const CONFIG_DIR = path.join(HOME, '.nexical');\n    const CONFIG_FILE = path.join(CONFIG_DIR, 'config.json');\n    return { CONFIG_DIR, CONFIG_FILE };\n};\n\ninterface Config {\n    token?: string;\n}\n\nexport function getConfig(): Config {\n    const { CONFIG_FILE } = getConfigPaths();\n    if (!fs.existsSync(CONFIG_FILE)) {\n        return {};\n    }\n    try {\n        const content = fs.readFileSync(CONFIG_FILE, 'utf-8');\n        return JSON.parse(content);\n    } catch (error) {\n        return {};\n    }\n}\n\nexport function saveToken(token: string) {\n    const { CONFIG_DIR, CONFIG_FILE } = getConfigPaths();\n    if (!fs.existsSync(CONFIG_DIR)) {\n        fs.mkdirSync(CONFIG_DIR, { recursive: true });\n    }\n    const config = getConfig();\n    config.token = token;\n    fs.writeFileSync(CONFIG_FILE, JSON.stringify(config, null, 2));\n}\n\nexport function getClient(): NexicalClient {\n    const config = getConfig();\n    return new NexicalClient({\n        token: config.token,\n        baseURL: process.env.NEXICAL_API_URL,\n    });\n}\n"],"mappings":";;;AACA,SAAS,qBAAqB;AAC9B,OAAO,QAAQ;AACf,OAAO,UAAU;AACjB,OAAO,QAAQ;AAEf,IAAM,iBAAiB,MAAM;AACzB,QAAM,OAAO,QAAQ,IAAI,QAAQ,GAAG,QAAQ;AAC5C,QAAM,aAAa,KAAK,KAAK,MAAM,UAAU;AAC7C,QAAM,cAAc,KAAK,KAAK,YAAY,aAAa;AACvD,SAAO,EAAE,YAAY,YAAY;AACrC;AAMO,SAAS,YAAoB;AAChC,QAAM,EAAE,YAAY,IAAI,eAAe;AACvC,MAAI,CAAC,GAAG,WAAW,WAAW,GAAG;AAC7B,WAAO,CAAC;AAAA,EACZ;AACA,MAAI;AACA,UAAM,UAAU,GAAG,aAAa,aAAa,OAAO;AACpD,WAAO,KAAK,MAAM,OAAO;AAAA,EAC7B,SAAS,OAAO;AACZ,WAAO,CAAC;AAAA,EACZ;AACJ;AAEO,SAAS,UAAU,OAAe;AACrC,QAAM,EAAE,YAAY,YAAY,IAAI,eAAe;AACnD,MAAI,CAAC,GAAG,WAAW,UAAU,GAAG;AAC5B,OAAG,UAAU,YAAY,EAAE,WAAW,KAAK,CAAC;AAAA,EAChD;AACA,QAAM,SAAS,UAAU;AACzB,SAAO,QAAQ;AACf,KAAG,cAAc,aAAa,KAAK,UAAU,QAAQ,MAAM,CAAC,CAAC;AACjE;AAEO,SAAS,YAA2B;AACvC,QAAM,SAAS,UAAU;AACzB,SAAO,IAAI,cAAc;AAAA,IACrB,OAAO,OAAO;AAAA,IACd,SAAS,QAAQ,IAAI;AAAA,EACzB,CAAC;AACL;","names":[]}

package/dist/src/commands/admin/create-user.d.ts

@@ -1,15 +0,0 @@
-import { BaseCommand } from '@nexical/cli-core';
-
-declare class AdminUsersCreateSystemCommand extends BaseCommand {
-    static description: string;
-    static args: {
-        args: {
-            name: string;
-            required: boolean;
-            description: string;
-        }[];
-    };
-    run(options: any): Promise<void>;
-}
-
-export { AdminUsersCreateSystemCommand as default };

package/dist/src/commands/admin/create-user.js

@@ -1,49 +0,0 @@
-import { createRequire } from "module"; const require = createRequire(import.meta.url);
-import {
-  getClient
-} from "../../../chunk-JDRAVUKK.js";
-
-// src/commands/admin/create-user.ts
-import { BaseCommand } from "@nexical/cli-core";
-var AdminUsersCreateSystemCommand = class extends BaseCommand {
-  static description = "Create a new system user";
-  static args = {
-    args: [
-      {
-        name: "name",
-        required: true,
-        description: "System user name"
-      },
-      {
-        name: "email",
-        required: true,
-        description: "System user email"
-      },
-      {
-        name: "password",
-        required: true,
-        description: "System user password"
-      }
-    ]
-  };
-  async run(options) {
-    const client = getClient();
-    const { name, email, password } = options;
-    try {
-      const response = await client.auth.createSystemUser({
-        fullName: name,
-        email,
-        password
-      });
-      const user = response.user;
-      this.success(`System user "${user.fullName}" created!`);
-      this.info(`ID: ${user.id}`);
-    } catch (error) {
-      this.error(`Failed to create system user: ${error.message}`);
-    }
-  }
-};
-export {
-  AdminUsersCreateSystemCommand as default
-};
-//# sourceMappingURL=create-user.js.map

package/dist/src/commands/admin/create-user.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../../src/commands/admin/create-user.ts"],"sourcesContent":["\nimport { BaseCommand } from '@nexical/cli-core';\nimport { getClient } from '../../utils/nexical-client.js';\n\nexport default class AdminUsersCreateSystemCommand extends BaseCommand {\n    static description = 'Create a new system user';\n\n    static args = {\n        args: [\n            {\n                name: 'name',\n                required: true,\n                description: 'System user name',\n            },\n            {\n                name: 'email',\n                required: true,\n                description: 'System user email',\n            },\n            {\n                name: 'password',\n                required: true,\n                description: 'System user password',\n            },\n        ],\n    };\n\n    async run(options: any) {\n        const client = getClient();\n        const { name, email, password } = options;\n\n        try {\n            const response = await client.auth.createSystemUser({\n                fullName: name,\n                email,\n                password,\n            });\n            const user = response.user;\n\n            this.success(`System user \"${user.fullName}\" created!`);\n            this.info(`ID: ${user.id}`);\n        } catch (error: any) {\n            this.error(`Failed to create system user: ${error.message}`);\n        }\n    }\n}\n"],"mappings":";;;;;;AACA,SAAS,mBAAmB;AAG5B,IAAqB,gCAArB,cAA2D,YAAY;AAAA,EACnE,OAAO,cAAc;AAAA,EAErB,OAAO,OAAO;AAAA,IACV,MAAM;AAAA,MACF;AAAA,QACI,MAAM;AAAA,QACN,UAAU;AAAA,QACV,aAAa;AAAA,MACjB;AAAA,MACA;AAAA,QACI,MAAM;AAAA,QACN,UAAU;AAAA,QACV,aAAa;AAAA,MACjB;AAAA,MACA;AAAA,QACI,MAAM;AAAA,QACN,UAAU;AAAA,QACV,aAAa;AAAA,MACjB;AAAA,IACJ;AAAA,EACJ;AAAA,EAEA,MAAM,IAAI,SAAc;AACpB,UAAM,SAAS,UAAU;AACzB,UAAM,EAAE,MAAM,OAAO,SAAS,IAAI;AAElC,QAAI;AACA,YAAM,WAAW,MAAM,OAAO,KAAK,iBAAiB;AAAA,QAChD,UAAU;AAAA,QACV;AAAA,QACA;AAAA,MACJ,CAAC;AACD,YAAM,OAAO,SAAS;AAEtB,WAAK,QAAQ,gBAAgB,KAAK,QAAQ,YAAY;AACtD,WAAK,KAAK,OAAO,KAAK,EAAE,EAAE;AAAA,IAC9B,SAAS,OAAY;AACjB,WAAK,MAAM,iCAAiC,MAAM,OAAO,EAAE;AAAA,IAC/D;AAAA,EACJ;AACJ;","names":[]}

package/dist/src/commands/branch/create.d.ts

@@ -1,19 +0,0 @@
-import { BaseCommand } from '@nexical/cli-core';
-
-declare class BranchesCreateCommand extends BaseCommand {
-    static description: string;
-    static args: {
-        args: {
-            name: string;
-            required: boolean;
-            description: string;
-        }[];
-        options: {
-            name: string;
-            description: string;
-        }[];
-    };
-    run(options: any): Promise<void>;
-}
-
-export { BranchesCreateCommand as default };

package/dist/src/commands/branch/create.js

@@ -1,59 +0,0 @@
-import { createRequire } from "module"; const require = createRequire(import.meta.url);
-import {
-  getClient
-} from "../../../chunk-JDRAVUKK.js";
-
-// src/commands/branch/create.ts
-import { BaseCommand } from "@nexical/cli-core";
-var BranchesCreateCommand = class extends BaseCommand {
-  static description = "Create a new branch";
-  static args = {
-    args: [
-      {
-        name: "teamId",
-        required: true,
-        description: "Team ID"
-      },
-      {
-        name: "projectId",
-        required: true,
-        description: "Project ID"
-      },
-      {
-        name: "name",
-        required: true,
-        description: "Name of the branch"
-      }
-    ],
-    options: [
-      {
-        name: "--preview <url>",
-        description: "Preview URL"
-      }
-    ]
-  };
-  async run(options) {
-    const client = getClient();
-    const { teamId, projectId, name, preview } = options;
-    const tid = parseInt(teamId, 10);
-    const pid = parseInt(projectId, 10);
-    if (isNaN(tid) || isNaN(pid)) {
-      this.error("IDs must be numbers.");
-      return;
-    }
-    try {
-      const branch = await client.branches.create(tid, pid, {
-        name,
-        previewUrl: preview
-      });
-      this.success(`Branch "${branch.name}" created!`);
-      this.info(`ID: ${branch.id}`);
-    } catch (error) {
-      this.error(`Failed to create branch: ${error.message}`);
-    }
-  }
-};
-export {
-  BranchesCreateCommand as default
-};
-//# sourceMappingURL=create.js.map

package/dist/src/commands/branch/create.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../../src/commands/branch/create.ts"],"sourcesContent":["\nimport { BaseCommand } from '@nexical/cli-core';\nimport { getClient } from '../../utils/nexical-client.js';\n\nexport default class BranchesCreateCommand extends BaseCommand {\n    static description = 'Create a new branch';\n\n    static args = {\n        args: [\n            {\n                name: 'teamId',\n                required: true,\n                description: 'Team ID',\n            },\n            {\n                name: 'projectId',\n                required: true,\n                description: 'Project ID',\n            },\n            {\n                name: 'name',\n                required: true,\n                description: 'Name of the branch',\n            },\n        ],\n        options: [\n            {\n                name: '--preview <url>',\n                description: 'Preview URL',\n            },\n        ],\n    };\n\n    async run(options: any) {\n        const client = getClient();\n        const { teamId, projectId, name, preview } = options;\n        const tid = parseInt(teamId, 10);\n        const pid = parseInt(projectId, 10);\n\n        if (isNaN(tid) || isNaN(pid)) {\n            this.error('IDs must be numbers.');\n            return;\n        }\n\n        try {\n            const branch = await client.branches.create(tid, pid, {\n                name,\n                previewUrl: preview,\n            });\n\n            this.success(`Branch \"${branch.name}\" created!`);\n            this.info(`ID: ${branch.id}`);\n        } catch (error: any) {\n            this.error(`Failed to create branch: ${error.message}`);\n        }\n    }\n}\n"],"mappings":";;;;;;AACA,SAAS,mBAAmB;AAG5B,IAAqB,wBAArB,cAAmD,YAAY;AAAA,EAC3D,OAAO,cAAc;AAAA,EAErB,OAAO,OAAO;AAAA,IACV,MAAM;AAAA,MACF;AAAA,QACI,MAAM;AAAA,QACN,UAAU;AAAA,QACV,aAAa;AAAA,MACjB;AAAA,MACA;AAAA,QACI,MAAM;AAAA,QACN,UAAU;AAAA,QACV,aAAa;AAAA,MACjB;AAAA,MACA;AAAA,QACI,MAAM;AAAA,QACN,UAAU;AAAA,QACV,aAAa;AAAA,MACjB;AAAA,IACJ;AAAA,IACA,SAAS;AAAA,MACL;AAAA,QACI,MAAM;AAAA,QACN,aAAa;AAAA,MACjB;AAAA,IACJ;AAAA,EACJ;AAAA,EAEA,MAAM,IAAI,SAAc;AACpB,UAAM,SAAS,UAAU;AACzB,UAAM,EAAE,QAAQ,WAAW,MAAM,QAAQ,IAAI;AAC7C,UAAM,MAAM,SAAS,QAAQ,EAAE;AAC/B,UAAM,MAAM,SAAS,WAAW,EAAE;AAElC,QAAI,MAAM,GAAG,KAAK,MAAM,GAAG,GAAG;AAC1B,WAAK,MAAM,sBAAsB;AACjC;AAAA,IACJ;AAEA,QAAI;AACA,YAAM,SAAS,MAAM,OAAO,SAAS,OAAO,KAAK,KAAK;AAAA,QAClD;AAAA,QACA,YAAY;AAAA,MAChB,CAAC;AAED,WAAK,QAAQ,WAAW,OAAO,IAAI,YAAY;AAC/C,WAAK,KAAK,OAAO,OAAO,EAAE,EAAE;AAAA,IAChC,SAAS,OAAY;AACjB,WAAK,MAAM,4BAA4B,MAAM,OAAO,EAAE;AAAA,IAC1D;AAAA,EACJ;AACJ;","names":[]}

package/dist/src/commands/branch/delete.d.ts

@@ -1,15 +0,0 @@
-import { BaseCommand } from '@nexical/cli-core';
-
-declare class BranchesDeleteCommand extends BaseCommand {
-    static description: string;
-    static args: {
-        args: {
-            name: string;
-            required: boolean;
-            description: string;
-        }[];
-    };
-    run(options: any): Promise<void>;
-}
-
-export { BranchesDeleteCommand as default };

package/dist/src/commands/branch/delete.js

@@ -1,50 +0,0 @@
-import { createRequire } from "module"; const require = createRequire(import.meta.url);
-import {
-  getClient
-} from "../../../chunk-JDRAVUKK.js";
-
-// src/commands/branch/delete.ts
-import { BaseCommand } from "@nexical/cli-core";
-var BranchesDeleteCommand = class extends BaseCommand {
-  static description = "Delete a branch";
-  static args = {
-    args: [
-      {
-        name: "teamId",
-        required: true,
-        description: "Team ID"
-      },
-      {
-        name: "projectId",
-        required: true,
-        description: "Project ID"
-      },
-      {
-        name: "branchId",
-        required: true,
-        description: "Branch ID"
-      }
-    ]
-  };
-  async run(options) {
-    const client = getClient();
-    const { teamId, projectId, branchId } = options;
-    const tid = parseInt(teamId, 10);
-    const pid = parseInt(projectId, 10);
-    const bid = parseInt(branchId, 10);
-    if (isNaN(tid) || isNaN(pid) || isNaN(bid)) {
-      this.error("IDs must be numbers.");
-      return;
-    }
-    try {
-      await client.branches.delete(tid, pid, bid);
-      this.success(`Branch ${bid} deleted.`);
-    } catch (error) {
-      this.error(`Failed to delete branch: ${error.message}`);
-    }
-  }
-};
-export {
-  BranchesDeleteCommand as default
-};
-//# sourceMappingURL=delete.js.map

package/dist/src/commands/branch/delete.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../../src/commands/branch/delete.ts"],"sourcesContent":["\nimport { BaseCommand } from '@nexical/cli-core';\nimport { getClient } from '../../utils/nexical-client.js';\n\nexport default class BranchesDeleteCommand extends BaseCommand {\n    static description = 'Delete a branch';\n\n    static args = {\n        args: [\n            {\n                name: 'teamId',\n                required: true,\n                description: 'Team ID',\n            },\n            {\n                name: 'projectId',\n                required: true,\n                description: 'Project ID',\n            },\n            {\n                name: 'branchId',\n                required: true,\n                description: 'Branch ID',\n            },\n        ],\n    };\n\n    async run(options: any) {\n        const client = getClient();\n        const { teamId, projectId, branchId } = options;\n        const tid = parseInt(teamId, 10);\n        const pid = parseInt(projectId, 10);\n        const bid = parseInt(branchId, 10);\n\n        if (isNaN(tid) || isNaN(pid) || isNaN(bid)) {\n            this.error('IDs must be numbers.');\n            return;\n        }\n\n        try {\n            await client.branches.delete(tid, pid, bid);\n            this.success(`Branch ${bid} deleted.`);\n        } catch (error: any) {\n            this.error(`Failed to delete branch: ${error.message}`);\n        }\n    }\n}\n"],"mappings":";;;;;;AACA,SAAS,mBAAmB;AAG5B,IAAqB,wBAArB,cAAmD,YAAY;AAAA,EAC3D,OAAO,cAAc;AAAA,EAErB,OAAO,OAAO;AAAA,IACV,MAAM;AAAA,MACF;AAAA,QACI,MAAM;AAAA,QACN,UAAU;AAAA,QACV,aAAa;AAAA,MACjB;AAAA,MACA;AAAA,QACI,MAAM;AAAA,QACN,UAAU;AAAA,QACV,aAAa;AAAA,MACjB;AAAA,MACA;AAAA,QACI,MAAM;AAAA,QACN,UAAU;AAAA,QACV,aAAa;AAAA,MACjB;AAAA,IACJ;AAAA,EACJ;AAAA,EAEA,MAAM,IAAI,SAAc;AACpB,UAAM,SAAS,UAAU;AACzB,UAAM,EAAE,QAAQ,WAAW,SAAS,IAAI;AACxC,UAAM,MAAM,SAAS,QAAQ,EAAE;AAC/B,UAAM,MAAM,SAAS,WAAW,EAAE;AAClC,UAAM,MAAM,SAAS,UAAU,EAAE;AAEjC,QAAI,MAAM,GAAG,KAAK,MAAM,GAAG,KAAK,MAAM,GAAG,GAAG;AACxC,WAAK,MAAM,sBAAsB;AACjC;AAAA,IACJ;AAEA,QAAI;AACA,YAAM,OAAO,SAAS,OAAO,KAAK,KAAK,GAAG;AAC1C,WAAK,QAAQ,UAAU,GAAG,WAAW;AAAA,IACzC,SAAS,OAAY;AACjB,WAAK,MAAM,4BAA4B,MAAM,OAAO,EAAE;AAAA,IAC1D;AAAA,EACJ;AACJ;","names":[]}

package/dist/src/commands/branch/get.d.ts

@@ -1,15 +0,0 @@
-import { BaseCommand } from '@nexical/cli-core';
-
-declare class BranchesGetCommand extends BaseCommand {
-    static description: string;
-    static args: {
-        args: {
-            name: string;
-            required: boolean;
-            description: string;
-        }[];
-    };
-    run(options: any): Promise<void>;
-}
-
-export { BranchesGetCommand as default };