@meltstudio/meltctl 4.34.0 → 4.36.0

package/dist/commands/audit.test.js

@@ -7,9 +7,15 @@ vi.mock('fs-extra', () => ({
         writeFile: vi.fn(),
     },
 }));
+const mockClient = vi.hoisted(() => ({
+    audits: {
+        submit: vi.fn(),
+        list: vi.fn(),
+        get: vi.fn(),
+    },
+}));
 vi.mock('../utils/api.js', () => ({
-    getToken: vi.fn(),
-    tokenFetch: vi.fn(),
+    getClient: vi.fn().mockResolvedValue(mockClient),
 }));
 vi.mock('../utils/git.js', () => ({
     getGitBranch: vi.fn(),
@@ -19,7 +25,6 @@ vi.mock('../utils/git.js', () => ({
     findMdFiles: vi.fn(),
 }));
 import fs from 'fs-extra';
-import { getToken, tokenFetch } from '../utils/api.js';
 import { getGitBranch, getGitCommit, getGitRepository, getProjectName, findMdFiles, } from '../utils/git.js';
 import { auditSubmitCommand, auditListCommand, auditViewCommand } from './audit.js';
 beforeEach(() => {
@@ -33,7 +38,6 @@ beforeEach(() => {
 describe('auditSubmitCommand', () => {
     function setupGitMocks() {
         ;
-        getToken.mockResolvedValue('test-token');
         getGitBranch.mockReturnValue('main');
         getGitCommit.mockReturnValue('abc1234');
         getGitRepository.mockReturnValue({
@@ -46,60 +50,52 @@ describe('auditSubmitCommand', () => {
         setupGitMocks();
         fs.pathExists.mockResolvedValue(true);
         fs.readFile.mockResolvedValue('# Security Audit\nFindings here.');
-        const mockResponse = {
-            ok: true,
-            json: vi.fn().mockResolvedValue({ id: 'audit-123' }),
-        };
-        tokenFetch.mockResolvedValue(mockResponse);
+        mockClient.audits.submit.mockResolvedValue({
+            id: 'audit-123',
+            createdAt: '2026-03-26T00:00:00Z',
+        });
         await auditSubmitCommand('2026-03-26-security-audit.md');
-        expect(tokenFetch).toHaveBeenCalledWith('test-token', '/audits', expect.objectContaining({
-            method: 'POST',
-            body: expect.stringContaining('"type":"security-audit"'),
+        expect(mockClient.audits.submit).toHaveBeenCalledWith(expect.objectContaining({
+            type: 'security-audit',
         }));
     });
     it('submits audit with type "ux-audit" when filename contains ux-audit', async () => {
         setupGitMocks();
         fs.pathExists.mockResolvedValue(true);
         fs.readFile.mockResolvedValue('# UX Audit');
-        const mockResponse = {
-            ok: true,
-            json: vi.fn().mockResolvedValue({ id: 'audit-456' }),
-        };
-        tokenFetch.mockResolvedValue(mockResponse);
+        mockClient.audits.submit.mockResolvedValue({
+            id: 'audit-456',
+            createdAt: '2026-03-26T00:00:00Z',
+        });
         await auditSubmitCommand('UX-AUDIT.md');
-        expect(tokenFetch).toHaveBeenCalledWith('test-token', '/audits', expect.objectContaining({
-            method: 'POST',
-            body: expect.stringContaining('"type":"ux-audit"'),
+        expect(mockClient.audits.submit).toHaveBeenCalledWith(expect.objectContaining({
+            type: 'ux-audit',
         }));
     });
     it('submits audit with type "audit" for generic audit filenames', async () => {
         setupGitMocks();
         fs.pathExists.mockResolvedValue(true);
         fs.readFile.mockResolvedValue('# Audit');
-        const mockResponse = {
-            ok: true,
-            json: vi.fn().mockResolvedValue({ id: 'audit-789' }),
-        };
-        tokenFetch.mockResolvedValue(mockResponse);
+        mockClient.audits.submit.mockResolvedValue({
+            id: 'audit-789',
+            createdAt: '2026-03-26T00:00:00Z',
+        });
         await auditSubmitCommand('AUDIT.md');
-        expect(tokenFetch).toHaveBeenCalledWith('test-token', '/audits', expect.objectContaining({
-            method: 'POST',
-            body: expect.stringContaining('"type":"audit"'),
+        expect(mockClient.audits.submit).toHaveBeenCalledWith(expect.objectContaining({
+            type: 'audit',
         }));
     });
     it('submits audit with type "audit" for random filenames', async () => {
         setupGitMocks();
         fs.pathExists.mockResolvedValue(true);
         fs.readFile.mockResolvedValue('# Random');
-        const mockResponse = {
-            ok: true,
-            json: vi.fn().mockResolvedValue({ id: 'audit-000' }),
-        };
-        tokenFetch.mockResolvedValue(mockResponse);
+        mockClient.audits.submit.mockResolvedValue({
+            id: 'audit-000',
+            createdAt: '2026-03-26T00:00:00Z',
+        });
         await auditSubmitCommand('random-file.md');
-        expect(tokenFetch).toHaveBeenCalledWith('test-token', '/audits', expect.objectContaining({
-            method: 'POST',
-            body: expect.stringContaining('"type":"audit"'),
+        expect(mockClient.audits.submit).toHaveBeenCalledWith(expect.objectContaining({
+            type: 'audit',
         }));
     });
     it('exits with error when file not found', async () => {
@@ -112,15 +108,12 @@ describe('auditSubmitCommand', () => {
         setupGitMocks();
         vi.mocked(fs.pathExists).mockResolvedValue(true);
         vi.mocked(fs.readFile).mockResolvedValue('audit content here');
-        const mockResponse = {
-            ok: true,
-            json: vi.fn().mockResolvedValue({ id: 'audit-100' }),
-        };
-        tokenFetch.mockResolvedValue(mockResponse);
+        mockClient.audits.submit.mockResolvedValue({
+            id: 'audit-100',
+            createdAt: '2026-03-26T00:00:00Z',
+        });
         await auditSubmitCommand('AUDIT.md');
-        const call = tokenFetch.mock.calls[0];
-        const body = JSON.parse(call[2].body);
-        expect(body).toEqual({
+        expect(mockClient.audits.submit).toHaveBeenCalledWith({
             type: 'audit',
             project: 'test-project',
             repository: 'Org/Repo',
@@ -135,12 +128,7 @@ describe('auditSubmitCommand', () => {
         setupGitMocks();
         fs.pathExists.mockResolvedValue(true);
         fs.readFile.mockResolvedValue('content');
-        const mockResponse = {
-            ok: false,
-            statusText: 'Bad Request',
-            json: vi.fn().mockResolvedValue({ error: 'Invalid content' }),
-        };
-        tokenFetch.mockResolvedValue(mockResponse);
+        mockClient.audits.submit.mockRejectedValue(new Error('Invalid content'));
         await expect(auditSubmitCommand('AUDIT.md')).rejects.toThrow('process.exit(1)');
     });
     it('auto-detects audit file from .audits/ directory when no file provided', async () => {
@@ -148,20 +136,17 @@ describe('auditSubmitCommand', () => {
         findMdFiles.mockResolvedValue(['/project/.audits/2026-03-26-security-audit.md']);
         fs.pathExists.mockResolvedValue(true);
         fs.readFile.mockResolvedValue('auto-detected content');
-        const mockResponse = {
-            ok: true,
-            json: vi.fn().mockResolvedValue({ id: 'audit-auto' }),
-        };
-        tokenFetch.mockResolvedValue(mockResponse);
+        mockClient.audits.submit.mockResolvedValue({
+            id: 'audit-auto',
+            createdAt: '2026-03-26T00:00:00Z',
+        });
         await auditSubmitCommand();
-        expect(tokenFetch).toHaveBeenCalledWith('test-token', '/audits', expect.objectContaining({
-            method: 'POST',
-            body: expect.stringContaining('"type":"security-audit"'),
+        expect(mockClient.audits.submit).toHaveBeenCalledWith(expect.objectContaining({
+            type: 'security-audit',
         }));
     });
     it('exits with error when no file provided and none auto-detected', async () => {
         ;
-        getToken.mockResolvedValue('test-token');
         findMdFiles.mockResolvedValue([]);
         fs.pathExists.mockResolvedValue(false);
         await expect(auditSubmitCommand()).rejects.toThrow('process.exit(1)');
@@ -170,122 +155,89 @@ describe('auditSubmitCommand', () => {
 });
 describe('auditListCommand', () => {
     it('calls API with correct query params', async () => {
-        ;
-        getToken.mockResolvedValue('test-token');
-        const mockResponse = {
-            ok: true,
-            status: 200,
-            json: vi.fn().mockResolvedValue({ audits: [], count: 0 }),
-        };
-        tokenFetch.mockResolvedValue(mockResponse);
+        mockClient.audits.list.mockResolvedValue({ audits: [], count: 0 });
         await auditListCommand({ type: 'ux-audit', repository: 'Org/Repo', limit: '5' });
-        expect(tokenFetch).toHaveBeenCalledWith('test-token', expect.stringContaining('/audits?'));
-        const url = tokenFetch.mock.calls[0][1];
-        expect(url).toContain('type=ux-audit');
-        expect(url).toContain('repository=Org%2FRepo');
-        expect(url).toContain('limit=5');
+        expect(mockClient.audits.list).toHaveBeenCalledWith({
+            type: 'ux-audit',
+            repository: 'Org/Repo',
+            latest: undefined,
+            limit: 5,
+        });
     });
     it('passes latest=true query param when option set', async () => {
-        ;
-        getToken.mockResolvedValue('test-token');
-        const mockResponse = {
-            ok: true,
-            status: 200,
-            json: vi.fn().mockResolvedValue({ audits: [], count: 0 }),
-        };
-        tokenFetch.mockResolvedValue(mockResponse);
+        mockClient.audits.list.mockResolvedValue({ audits: [], count: 0 });
         await auditListCommand({ latest: true });
-        const url = tokenFetch.mock.calls[0][1];
-        expect(url).toContain('latest=true');
+        expect(mockClient.audits.list).toHaveBeenCalledWith(expect.objectContaining({
+            latest: true,
+        }));
     });
     it('exits with error on 403 response', async () => {
-        ;
-        getToken.mockResolvedValue('test-token');
-        const mockResponse = {
-            ok: false,
-            status: 403,
-            statusText: 'Forbidden',
-        };
-        tokenFetch.mockResolvedValue(mockResponse);
+        mockClient.audits.list.mockRejectedValue(new Error('Access denied. Only Team Managers can list audits.'));
         await expect(auditListCommand({})).rejects.toThrow('process.exit(1)');
         expect(console.error).toHaveBeenCalled();
     });
     it('displays audit list when audits exist', async () => {
-        ;
-        getToken.mockResolvedValue('test-token');
-        const mockResponse = {
-            ok: true,
-            status: 200,
-            json: vi.fn().mockResolvedValue({
-                audits: [
-                    {
-                        id: '1',
-                        type: 'audit',
-                        project: 'my-project',
-                        repository: 'Org/Repo',
-                        author: 'dev@meltstudio.co',
-                        branch: 'main',
-                        commit: 'abc1234',
-                        createdAt: '2026-03-25T10:00:00Z',
-                    },
-                ],
-                count: 1,
-            }),
-        };
-        tokenFetch.mockResolvedValue(mockResponse);
+        mockClient.audits.list.mockResolvedValue({
+            audits: [
+                {
+                    id: '1',
+                    type: 'audit',
+                    project: 'my-project',
+                    repository: 'Org/Repo',
+                    author: 'dev@meltstudio.co',
+                    branch: 'main',
+                    commit: 'abc1234',
+                    createdAt: '2026-03-25T10:00:00Z',
+                },
+            ],
+            count: 1,
+        });
         await auditListCommand({});
         expect(console.log).toHaveBeenCalled();
     });
     it('displays age-colored output when latest option is set', async () => {
-        ;
-        getToken.mockResolvedValue('test-token');
         const now = Date.now();
         const threeDaysAgo = new Date(now - 3 * 24 * 60 * 60 * 1000).toISOString();
         const fifteenDaysAgo = new Date(now - 15 * 24 * 60 * 60 * 1000).toISOString();
         const sixtyDaysAgo = new Date(now - 60 * 24 * 60 * 60 * 1000).toISOString();
-        const mockResponse = {
-            ok: true,
-            status: 200,
-            json: vi.fn().mockResolvedValue({
-                audits: [
-                    {
-                        id: '1',
-                        type: 'audit',
-                        project: 'project-a',
-                        repository: 'Org/RepoA',
-                        author: 'dev1@meltstudio.co',
-                        branch: 'main',
-                        commit: 'aaa1111',
-                        createdAt: threeDaysAgo,
-                        created_at: threeDaysAgo,
-                    },
-                    {
-                        id: '2',
-                        type: 'ux-audit',
-                        project: 'project-b',
-                        repository: 'Org/RepoB',
-                        author: 'dev2@meltstudio.co',
-                        branch: 'main',
-                        commit: 'bbb2222',
-                        createdAt: fifteenDaysAgo,
-                        created_at: fifteenDaysAgo,
-                    },
-                    {
-                        id: '3',
-                        type: 'security-audit',
-                        project: 'project-c',
-                        repository: 'Org/RepoC',
-                        author: 'dev3@meltstudio.co',
-                        branch: 'main',
-                        commit: 'ccc3333',
-                        createdAt: sixtyDaysAgo,
-                        created_at: sixtyDaysAgo,
-                    },
-                ],
-                count: 3,
-            }),
-        };
-        tokenFetch.mockResolvedValue(mockResponse);
+        mockClient.audits.list.mockResolvedValue({
+            audits: [
+                {
+                    id: '1',
+                    type: 'audit',
+                    project: 'project-a',
+                    repository: 'Org/RepoA',
+                    author: 'dev1@meltstudio.co',
+                    branch: 'main',
+                    commit: 'aaa1111',
+                    createdAt: threeDaysAgo,
+                    created_at: threeDaysAgo,
+                },
+                {
+                    id: '2',
+                    type: 'ux-audit',
+                    project: 'project-b',
+                    repository: 'Org/RepoB',
+                    author: 'dev2@meltstudio.co',
+                    branch: 'main',
+                    commit: 'bbb2222',
+                    createdAt: fifteenDaysAgo,
+                    created_at: fifteenDaysAgo,
+                },
+                {
+                    id: '3',
+                    type: 'security-audit',
+                    project: 'project-c',
+                    repository: 'Org/RepoC',
+                    author: 'dev3@meltstudio.co',
+                    branch: 'main',
+                    commit: 'ccc3333',
+                    createdAt: sixtyDaysAgo,
+                    created_at: sixtyDaysAgo,
+                },
+            ],
+            count: 3,
+        });
         await auditListCommand({ latest: true });
         const logCalls = console.log.mock.calls.map((c) => String(c[0]));
         // Should display "Latest Audits" header
@@ -293,30 +245,20 @@ describe('auditListCommand', () => {
         // Should display AGE column header
         expect(logCalls.some((msg) => msg.includes('AGE'))).toBe(true);
     });
-    it('exits with error when auditListCommand tokenFetch throws', async () => {
-        ;
-        getToken.mockResolvedValue('test-token');
-        tokenFetch.mockRejectedValue(new Error('Network error'));
+    it('exits with error when auditListCommand throws', async () => {
+        mockClient.audits.list.mockRejectedValue(new Error('Network error'));
         await expect(auditListCommand({})).rejects.toThrow('process.exit(1)');
         const errorCalls = console.error.mock.calls.map((c) => String(c[0]));
         expect(errorCalls.some((msg) => msg.includes('Network error'))).toBe(true);
     });
     it('exits with error when findMdFiles throws (e.g. .audits/ unreadable)', async () => {
         ;
-        getToken.mockResolvedValue('test-token');
         findMdFiles.mockRejectedValue(new Error('EACCES: permission denied'));
         fs.pathExists.mockResolvedValue(false);
         await expect(auditSubmitCommand()).rejects.toThrow();
     });
     it('shows "No audits found" when list is empty', async () => {
-        ;
-        getToken.mockResolvedValue('test-token');
-        const mockResponse = {
-            ok: true,
-            status: 200,
-            json: vi.fn().mockResolvedValue({ audits: [], count: 0 }),
-        };
-        tokenFetch.mockResolvedValue(mockResponse);
+        mockClient.audits.list.mockResolvedValue({ audits: [], count: 0 });
         await auditListCommand({});
         const errorCalls = console.log.mock.calls.map((c) => c[0]);
         expect(errorCalls.some((msg) => typeof msg === 'string' && msg.includes('No audits found'))).toBe(true);
@@ -335,50 +277,25 @@ describe('auditViewCommand', () => {
         createdAt: '2026-03-25T10:00:00Z',
     };
     it('exits with "Access denied" on 403 response', async () => {
-        ;
-        getToken.mockResolvedValue('test-token');
-        tokenFetch.mockResolvedValue({
-            ok: false,
-            status: 403,
-            statusText: 'Forbidden',
-        });
+        mockClient.audits.get.mockRejectedValue(new Error('Access denied. Only Team Managers can list audits.'));
         await expect(auditViewCommand('audit-abc123', {})).rejects.toThrow('process.exit(1)');
         const errorCalls = console.error.mock.calls.map((c) => String(c[0]));
         expect(errorCalls.some((msg) => msg.includes('Access denied'))).toBe(true);
     });
     it('exits with "Audit not found" on 404 response', async () => {
-        ;
-        getToken.mockResolvedValue('test-token');
-        tokenFetch.mockResolvedValue({
-            ok: false,
-            status: 404,
-            statusText: 'Not Found',
-        });
+        mockClient.audits.get.mockRejectedValue(new Error('Audit not found: nonexistent-id'));
         await expect(auditViewCommand('nonexistent-id', {})).rejects.toThrow('process.exit(1)');
         const errorCalls = console.error.mock.calls.map((c) => String(c[0]));
         expect(errorCalls.some((msg) => msg.includes('Audit not found'))).toBe(true);
     });
     it('exits with error from body on non-ok response', async () => {
-        ;
-        getToken.mockResolvedValue('test-token');
-        tokenFetch.mockResolvedValue({
-            ok: false,
-            status: 500,
-            statusText: 'Internal Server Error',
-            json: vi.fn().mockResolvedValue({ error: 'Database unavailable' }),
-        });
+        mockClient.audits.get.mockRejectedValue(new Error('Database unavailable'));
         await expect(auditViewCommand('audit-abc123', {})).rejects.toThrow('process.exit(1)');
         const errorCalls = console.error.mock.calls.map((c) => String(c[0]));
         expect(errorCalls.some((msg) => msg.includes('Database unavailable'))).toBe(true);
     });
     it('prints audit content with header when no --output flag', async () => {
-        ;
-        getToken.mockResolvedValue('test-token');
-        tokenFetch.mockResolvedValue({
-            ok: true,
-            status: 200,
-            json: vi.fn().mockResolvedValue(sampleAudit),
-        });
+        mockClient.audits.get.mockResolvedValue(sampleAudit);
         await auditViewCommand('audit-abc123', {});
         const logCalls = console.log.mock.calls.map((c) => String(c[0]));
         // Header should contain type label, repo, author, and date
@@ -389,13 +306,7 @@ describe('auditViewCommand', () => {
         expect(logCalls.some((msg) => msg.includes('# UX Audit'))).toBe(true);
     });
     it('writes content to file with --output flag', async () => {
-        ;
-        getToken.mockResolvedValue('test-token');
-        tokenFetch.mockResolvedValue({
-            ok: true,
-            status: 200,
-            json: vi.fn().mockResolvedValue(sampleAudit),
-        });
+        mockClient.audits.get.mockResolvedValue(sampleAudit);
         fs.ensureDir.mockResolvedValue(undefined);
         fs.writeFile.mockResolvedValue(undefined);
         await auditViewCommand('audit-abc123', { output: 'output/audit.md' });
@@ -405,9 +316,7 @@ describe('auditViewCommand', () => {
         expect(logCalls.some((msg) => msg.includes('Audit saved to'))).toBe(true);
     });
     it('exits with error message on network error', async () => {
-        ;
-        getToken.mockResolvedValue('test-token');
-        tokenFetch.mockRejectedValue(new Error('Network error'));
+        mockClient.audits.get.mockRejectedValue(new Error('Network error'));
         await expect(auditViewCommand('audit-abc123', {})).rejects.toThrow('process.exit(1)');
         const errorCalls = console.error.mock.calls.map((c) => String(c[0]));
         expect(errorCalls.some((msg) => msg.includes('Network error'))).toBe(true);

package/dist/commands/coins.js

@@ -1,5 +1,6 @@
 import chalk from 'chalk';
-import { isAuthenticated, authenticatedFetch } from '../utils/auth.js';
+import { isAuthenticated } from '../utils/auth.js';
+import { getClient } from '../utils/api.js';
 export async function coinsCommand(options) {
     if (!(await isAuthenticated())) {
         console.error(chalk.red('Not authenticated. Run `npx @meltstudio/meltctl@latest login` first.'));
@@ -13,37 +14,38 @@ export async function coinsCommand(options) {
     }
 }
 async function showBalance() {
-    const res = await authenticatedFetch('/coins');
-    if (!res.ok) {
-        const body = (await res.json());
-        console.error(chalk.red(`Failed to fetch coins: ${body.error ?? res.statusText}`));
+    const client = await getClient();
+    try {
+        const data = await client.coins.getBalance();
+        console.log(chalk.bold.cyan('\n  Your Coins (last 28 days)'));
+        console.log(`  ${chalk.bold(String(data.coins))} coin${data.coins !== 1 ? 's' : ''} received\n`);
+    }
+    catch (error) {
+        console.error(chalk.red(`Failed to fetch coins: ${error instanceof Error ? error.message : 'Unknown error'}`));
         process.exit(1);
     }
-    const data = (await res.json());
-    console.log(chalk.bold.cyan('\n  Your Coins (last 28 days)'));
-    console.log(`  ${chalk.bold(String(data.coins))} coin${data.coins !== 1 ? 's' : ''} received\n`);
 }
 async function showLeaderboard() {
-    const res = await authenticatedFetch('/coins/leaderboard');
-    if (!res.ok) {
-        const body = (await res.json());
-        console.error(chalk.red(`Failed to fetch leaderboard: ${body.error ?? res.statusText}`));
-        process.exit(1);
+    const client = await getClient();
+    try {
+        const entries = await client.coins.getLeaderboard();
+        if (entries.length === 0) {
+            console.log(chalk.yellow('\n  No coins have been sent in the last 28 days.\n'));
+            return;
+        }
+        console.log(chalk.bold.cyan('\n  Leaderboard (last 28 days)\n'));
+        const maxNameLen = Math.max(...entries.map(e => e.name.length), 4);
+        console.log(chalk.dim(`  ${'#'.padEnd(4)} ${'Name'.padEnd(maxNameLen)}  Coins`));
+        entries.forEach((entry, i) => {
+            const rank = String(i + 1).padEnd(4);
+            const name = entry.name.padEnd(maxNameLen);
+            const coins = String(entry.coins);
+            console.log(`  ${rank} ${name}  ${coins}`);
+        });
+        console.log();
     }
-    const entries = (await res.json());
-    if (entries.length === 0) {
-        console.log(chalk.yellow('\n  No coins have been sent in the last 28 days.\n'));
-        return;
+    catch (error) {
+        console.error(chalk.red(`Failed to fetch leaderboard: ${error instanceof Error ? error.message : 'Unknown error'}`));
+        process.exit(1);
     }
-    console.log(chalk.bold.cyan('\n  Leaderboard (last 28 days)\n'));
-    // Calculate column widths
-    const maxNameLen = Math.max(...entries.map(e => e.name.length), 4);
-    console.log(chalk.dim(`  ${'#'.padEnd(4)} ${'Name'.padEnd(maxNameLen)}  Coins`));
-    entries.forEach((entry, i) => {
-        const rank = String(i + 1).padEnd(4);
-        const name = entry.name.padEnd(maxNameLen);
-        const coins = String(entry.coins);
-        console.log(`  ${rank} ${name}  ${coins}`);
-    });
-    console.log();
 }