@meltstudio/meltctl 4.28.0 → 4.29.0

package/dist/utils/git.test.js

@@ -0,0 +1,184 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+vi.mock('child_process', () => ({
+    execSync: vi.fn(),
+}));
+vi.mock('fs-extra', () => ({
+    default: {
+        pathExistsSync: vi.fn(),
+        readJsonSync: vi.fn(),
+        pathExists: vi.fn(),
+        readdir: vi.fn(),
+        stat: vi.fn(),
+    },
+}));
+import { execSync } from 'child_process';
+import fs from 'fs-extra';
+import { getGitBranch, getGitCommit, getGitRepository, getProjectName, extractTicketId, findMdFiles, } from './git.js';
+beforeEach(() => {
+    vi.clearAllMocks();
+});
+describe('getGitBranch', () => {
+    it('returns trimmed branch name', () => {
+        ;
+        execSync.mockReturnValue('  feature/my-branch\n');
+        expect(getGitBranch()).toBe('feature/my-branch');
+    });
+    it('returns "unknown" when git command fails', () => {
+        ;
+        execSync.mockImplementation(() => {
+            throw new Error('not a git repo');
+        });
+        expect(getGitBranch()).toBe('unknown');
+    });
+});
+describe('getGitCommit', () => {
+    it('returns trimmed commit hash', () => {
+        ;
+        execSync.mockReturnValue('abc1234\n');
+        expect(getGitCommit()).toBe('abc1234');
+    });
+    it('returns "unknown" when git command fails', () => {
+        ;
+        execSync.mockImplementation(() => {
+            throw new Error('not a git repo');
+        });
+        expect(getGitCommit()).toBe('unknown');
+    });
+});
+describe('getGitRepository', () => {
+    it('parses SSH URL format', () => {
+        ;
+        execSync.mockReturnValue('git@github.com:Owner/Repo.git\n');
+        const result = getGitRepository();
+        expect(result).toEqual({
+            slug: 'Owner/Repo',
+            url: 'git@github.com:Owner/Repo.git',
+        });
+    });
+    it('parses HTTPS URL format', () => {
+        ;
+        execSync.mockReturnValue('https://github.com/Owner/Repo.git\n');
+        const result = getGitRepository();
+        expect(result).toEqual({
+            slug: 'Owner/Repo',
+            url: 'https://github.com/Owner/Repo.git',
+        });
+    });
+    it('parses HTTPS URL without .git suffix', () => {
+        ;
+        execSync.mockReturnValue('https://github.com/Owner/Repo\n');
+        const result = getGitRepository();
+        expect(result).toEqual({
+            slug: 'Owner/Repo',
+            url: 'https://github.com/Owner/Repo',
+        });
+    });
+    it('parses GitLab SSH URL', () => {
+        ;
+        execSync.mockReturnValue('git@gitlab.com:My-Org/My-Project.git\n');
+        const result = getGitRepository();
+        expect(result).toEqual({
+            slug: 'My-Org/My-Project',
+            url: 'git@gitlab.com:My-Org/My-Project.git',
+        });
+    });
+    it('returns null when git command fails', () => {
+        ;
+        execSync.mockImplementation(() => {
+            throw new Error('no remote');
+        });
+        expect(getGitRepository()).toBeNull();
+    });
+    it('falls back to raw URL when regex does not match', () => {
+        ;
+        execSync.mockReturnValue('some-weird-url\n');
+        const result = getGitRepository();
+        expect(result).toEqual({
+            slug: 'some-weird-url',
+            url: 'some-weird-url',
+        });
+    });
+});
+describe('getProjectName', () => {
+    it('returns name from package.json when available', () => {
+        ;
+        fs.pathExistsSync.mockReturnValue(true);
+        fs.readJsonSync.mockReturnValue({ name: '@meltstudio/meltctl' });
+        expect(getProjectName()).toBe('@meltstudio/meltctl');
+    });
+    it('returns directory basename when package.json has no name', () => {
+        ;
+        fs.pathExistsSync.mockReturnValue(true);
+        fs.readJsonSync.mockReturnValue({});
+        const result = getProjectName();
+        // Should be the basename of cwd
+        expect(typeof result).toBe('string');
+        expect(result.length).toBeGreaterThan(0);
+    });
+    it('returns directory basename when package.json does not exist', () => {
+        ;
+        fs.pathExistsSync.mockReturnValue(false);
+        const result = getProjectName();
+        expect(typeof result).toBe('string');
+        expect(result.length).toBeGreaterThan(0);
+    });
+    it('returns directory basename when readJsonSync throws', () => {
+        ;
+        fs.pathExistsSync.mockReturnValue(true);
+        fs.readJsonSync.mockImplementation(() => {
+            throw new Error('parse error');
+        });
+        const result = getProjectName();
+        expect(typeof result).toBe('string');
+        expect(result.length).toBeGreaterThan(0);
+    });
+});
+describe('extractTicketId', () => {
+    it('extracts ticket ID from branch name', () => {
+        expect(extractTicketId('feature/PROJ-123-add-login')).toBe('PROJ-123');
+    });
+    it('extracts ticket ID case-insensitively', () => {
+        expect(extractTicketId('fix/proj-456')).toBe('proj-456');
+    });
+    it('returns null when no ticket ID found', () => {
+        expect(extractTicketId('main')).toBeNull();
+        expect(extractTicketId('feature/add-login')).toBeNull();
+    });
+});
+describe('findMdFiles', () => {
+    it('returns empty array when directory does not exist', async () => {
+        ;
+        fs.pathExists.mockResolvedValue(false);
+        const result = await findMdFiles('/nonexistent');
+        expect(result).toEqual([]);
+    });
+    it('finds and sorts .md files by mtime descending', async () => {
+        ;
+        fs.pathExists.mockResolvedValue(true);
+        fs.readdir.mockResolvedValue([
+            { name: 'old.md', isDirectory: () => false, isFile: () => true },
+            { name: 'new.md', isDirectory: () => false, isFile: () => true },
+            { name: 'not-md.txt', isDirectory: () => false, isFile: () => true },
+        ]);
+        fs.stat
+            .mockResolvedValueOnce({ mtimeMs: 1000 }) // old.md
+            .mockResolvedValueOnce({ mtimeMs: 2000 }); // new.md
+        const result = await findMdFiles('/test-dir');
+        expect(result).toEqual(['/test-dir/new.md', '/test-dir/old.md']);
+    });
+    it('recurses into subdirectories', async () => {
+        ;
+        fs.pathExists.mockResolvedValue(true);
+        fs.readdir
+            .mockResolvedValueOnce([
+            { name: 'sub', isDirectory: () => true, isFile: () => false },
+            { name: 'root.md', isDirectory: () => false, isFile: () => true },
+        ])
+            .mockResolvedValueOnce([{ name: 'nested.md', isDirectory: () => false, isFile: () => true }]);
+        fs.stat
+            .mockResolvedValueOnce({ mtimeMs: 4000 }) // sub/nested.md
+            .mockResolvedValueOnce({ mtimeMs: 3000 }); // root.md
+        const result = await findMdFiles('/project');
+        expect(result).toEqual(['/project/sub/nested.md', '/project/root.md']);
+    });
+});

package/dist/utils/package-manager.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/utils/package-manager.test.js

@@ -0,0 +1,76 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+vi.mock('child_process', () => ({
+    execSync: vi.fn(),
+}));
+import { execSync } from 'child_process';
+import { detectPackageManager, getUpdateInstructions } from './package-manager.js';
+beforeEach(() => {
+    vi.clearAllMocks();
+});
+describe('detectPackageManager', () => {
+    it('returns npm when npm list succeeds', () => {
+        vi.mocked(execSync).mockReturnValueOnce('');
+        const result = detectPackageManager();
+        expect(result).toEqual({
+            type: 'npm',
+            updateCommand: 'npm install -g @meltstudio/meltctl@latest',
+        });
+        expect(execSync).toHaveBeenCalledWith('npm list -g @meltstudio/meltctl', expect.objectContaining({ encoding: 'utf-8', stdio: 'pipe' }));
+    });
+    it('returns yarn when npm fails but yarn succeeds', () => {
+        vi.mocked(execSync)
+            .mockImplementationOnce(() => {
+            throw new Error('npm not found');
+        })
+            .mockReturnValueOnce('');
+        const result = detectPackageManager();
+        expect(result).toEqual({
+            type: 'yarn',
+            updateCommand: 'yarn global add @meltstudio/meltctl@latest',
+        });
+    });
+    it('returns unknown when both npm and yarn fail', () => {
+        vi.mocked(execSync)
+            .mockImplementationOnce(() => {
+            throw new Error('npm not found');
+        })
+            .mockImplementationOnce(() => {
+            throw new Error('yarn not found');
+        });
+        const result = detectPackageManager();
+        expect(result).toEqual({
+            type: 'unknown',
+            updateCommand: 'npm install -g @meltstudio/meltctl@latest',
+        });
+    });
+});
+describe('getUpdateInstructions', () => {
+    it('returns npm-first instructions when detected via npm', () => {
+        vi.mocked(execSync).mockReturnValueOnce('');
+        const instructions = getUpdateInstructions();
+        expect(instructions[0]).toBe('npm install -g @meltstudio/meltctl@latest');
+        expect(instructions.some(l => l.includes('yarn'))).toBe(true);
+    });
+    it('returns yarn-first instructions when detected via yarn', () => {
+        vi.mocked(execSync)
+            .mockImplementationOnce(() => {
+            throw new Error('npm not found');
+        })
+            .mockReturnValueOnce('');
+        const instructions = getUpdateInstructions();
+        expect(instructions[0]).toBe('yarn global add @meltstudio/meltctl@latest');
+        expect(instructions.some(l => l.includes('npm'))).toBe(true);
+    });
+    it('returns npm default instructions when detection fails', () => {
+        vi.mocked(execSync)
+            .mockImplementationOnce(() => {
+            throw new Error('npm not found');
+        })
+            .mockImplementationOnce(() => {
+            throw new Error('yarn not found');
+        });
+        const instructions = getUpdateInstructions();
+        expect(instructions[0]).toBe('npm install -g @meltstudio/meltctl@latest');
+        expect(instructions.some(l => l.includes('yarn'))).toBe(true);
+    });
+});

package/dist/utils/templates.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/utils/templates.test.js

@@ -0,0 +1,50 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+vi.mock('./auth.js', () => ({
+    authenticatedFetch: vi.fn(),
+}));
+import { authenticatedFetch } from './auth.js';
+import { fetchTemplates } from './templates.js';
+beforeEach(() => {
+    vi.clearAllMocks();
+});
+describe('fetchTemplates', () => {
+    it('returns template files on success', async () => {
+        const mockFiles = {
+            'AGENTS.md': '# Agents content',
+            '.claude/skills/setup.md': '# Setup skill',
+        };
+        authenticatedFetch.mockResolvedValue({
+            ok: true,
+            json: vi.fn().mockResolvedValue({ files: mockFiles }),
+        });
+        const result = await fetchTemplates();
+        expect(authenticatedFetch).toHaveBeenCalledWith('/templates');
+        expect(result).toEqual(mockFiles);
+    });
+    it('throws error when API returns failure', async () => {
+        ;
+        authenticatedFetch.mockResolvedValue({
+            ok: false,
+            statusText: 'Unauthorized',
+        });
+        await expect(fetchTemplates()).rejects.toThrow('Failed to fetch templates: Unauthorized');
+    });
+    it('throws error when API returns 500', async () => {
+        ;
+        authenticatedFetch.mockResolvedValue({
+            ok: false,
+            statusText: 'Internal Server Error',
+        });
+        await expect(fetchTemplates()).rejects.toThrow('Failed to fetch templates: Internal Server Error');
+    });
+    it('calls authenticatedFetch with /templates path', async () => {
+        ;
+        authenticatedFetch.mockResolvedValue({
+            ok: true,
+            json: vi.fn().mockResolvedValue({ files: {} }),
+        });
+        await fetchTemplates();
+        expect(authenticatedFetch).toHaveBeenCalledTimes(1);
+        expect(authenticatedFetch).toHaveBeenCalledWith('/templates');
+    });
+});

package/dist/utils/version-check.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/utils/version-check.test.js

@@ -0,0 +1,135 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+vi.mock('child_process', () => ({
+    execSync: vi.fn(),
+}));
+vi.mock('fs-extra', () => ({
+    default: {
+        readJson: vi.fn(),
+    },
+}));
+import { execSync } from 'child_process';
+import fs from 'fs-extra';
+import { getCurrentCliVersion, getLatestCliVersion, compareVersions, isCI, checkAndEnforceUpdate, } from './version-check.js';
+beforeEach(() => {
+    vi.clearAllMocks();
+    vi.spyOn(console, 'log').mockImplementation(() => { });
+    vi.spyOn(console, 'error').mockImplementation(() => { });
+    // Clean up CI env vars
+    delete process.env.CI;
+    delete process.env.GITHUB_ACTIONS;
+    delete process.env.GITLAB_CI;
+    delete process.env.CIRCLECI;
+    delete process.env.TRAVIS;
+    delete process.env.JENKINS_URL;
+    delete process.env.BUILDKITE;
+    delete process.env.DRONE;
+    delete process.env.MELTCTL_SKIP_UPDATE_CHECK;
+});
+describe('getCurrentCliVersion', () => {
+    it('reads version from package.json', async () => {
+        ;
+        fs.readJson.mockResolvedValue({ version: '4.26.0' });
+        const version = await getCurrentCliVersion();
+        expect(version).toBe('4.26.0');
+    });
+});
+describe('getLatestCliVersion', () => {
+    it('returns version from npm registry', async () => {
+        ;
+        execSync.mockReturnValue('"4.27.0"\n');
+        const version = await getLatestCliVersion();
+        expect(version).toBe('4.27.0');
+    });
+    it('returns null on network error', async () => {
+        ;
+        execSync.mockImplementation(() => {
+            throw new Error('network error');
+        });
+        const version = await getLatestCliVersion();
+        expect(version).toBeNull();
+    });
+});
+describe('compareVersions', () => {
+    it('returns true when latest major is higher', () => {
+        expect(compareVersions('1.0.0', '2.0.0')).toBe(true);
+    });
+    it('returns true when latest minor is higher', () => {
+        expect(compareVersions('1.0.0', '1.1.0')).toBe(true);
+    });
+    it('returns true when latest patch is higher', () => {
+        expect(compareVersions('1.0.0', '1.0.1')).toBe(true);
+    });
+    it('returns false when versions are equal', () => {
+        expect(compareVersions('1.0.0', '1.0.0')).toBe(false);
+    });
+    it('returns false when current is newer', () => {
+        expect(compareVersions('2.0.0', '1.0.0')).toBe(false);
+    });
+    it('returns true when latest is stable and current is pre-release', () => {
+        expect(compareVersions('1.0.0-beta.1', '1.0.0')).toBe(true);
+    });
+    it('returns false when current is stable and latest is pre-release', () => {
+        expect(compareVersions('1.0.0', '1.0.0-beta.1')).toBe(false);
+    });
+    it('compares pre-release strings lexicographically', () => {
+        expect(compareVersions('1.0.0-alpha', '1.0.0-beta')).toBe(true);
+        expect(compareVersions('1.0.0-beta', '1.0.0-alpha')).toBe(false);
+    });
+    it('returns false when both pre-releases are equal', () => {
+        expect(compareVersions('1.0.0-beta', '1.0.0-beta')).toBe(false);
+    });
+});
+describe('isCI', () => {
+    it('returns false in non-CI environment', () => {
+        expect(isCI()).toBe(false);
+    });
+    it('returns true when CI env var is set', () => {
+        process.env.CI = 'true';
+        expect(isCI()).toBe(true);
+    });
+    it('returns true when GITHUB_ACTIONS is set', () => {
+        process.env.GITHUB_ACTIONS = 'true';
+        expect(isCI()).toBe(true);
+    });
+    it('returns true when MELTCTL_SKIP_UPDATE_CHECK is set', () => {
+        process.env.MELTCTL_SKIP_UPDATE_CHECK = '1';
+        expect(isCI()).toBe(true);
+    });
+});
+describe('checkAndEnforceUpdate', () => {
+    it('skips check in CI environment', async () => {
+        process.env.CI = 'true';
+        await checkAndEnforceUpdate();
+        // Should return early without checking versions
+        expect(fs.readJson).not.toHaveBeenCalled();
+    });
+    it('allows continuing when latest version cannot be fetched', async () => {
+        ;
+        fs.readJson.mockResolvedValue({ version: '4.26.0' });
+        execSync.mockImplementation(() => {
+            throw new Error('network error');
+        });
+        await checkAndEnforceUpdate();
+        // Should not throw or exit
+    });
+    it('allows continuing when versions are equal', async () => {
+        ;
+        fs.readJson.mockResolvedValue({ version: '4.26.0' });
+        execSync.mockReturnValue('"4.26.0"\n');
+        await checkAndEnforceUpdate();
+        // Should not throw or exit
+    });
+    it('calls process.exit when update is required', async () => {
+        const exitSpy = vi.spyOn(process, 'exit').mockImplementation(() => undefined);
+        fs.readJson.mockResolvedValue({ version: '4.25.0' });
+        execSync.mockReturnValue('"4.26.0"\n');
+        await checkAndEnforceUpdate();
+        expect(exitSpy).toHaveBeenCalledWith(1);
+    });
+    it('allows continuing when getCurrentCliVersion throws', async () => {
+        ;
+        fs.readJson.mockRejectedValue(new Error('file not found'));
+        await checkAndEnforceUpdate();
+        // Should not throw - error is caught
+    });
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@meltstudio/meltctl",
-  "version": "4.28.0",
+  "version": "4.29.0",
   "description": "AI-first development tools for teams - set up AGENTS.md, Claude Code, Cursor, and OpenCode standards",
   "main": "dist/index.js",
   "type": "module",
@@ -30,6 +30,7 @@
     "type-check": "tsc --noEmit",
     "format": "prettier --write src/**/*.ts",
     "format:check": "prettier --check src/**/*.ts",
+    "test": "vitest run",
     "prepublishOnly": "yarn build"
   },
   "keywords": [