@meltstudio/meltctl 4.28.0 → 4.29.0

package/dist/commands/audit.d.ts

@@ -5,3 +5,6 @@ export declare function auditListCommand(options: {
     latest?: boolean;
     limit?: string;
 }): Promise<void>;
+export declare function auditViewCommand(id: string, options: {
+    output?: string;
+}): Promise<void>;

package/dist/commands/audit.js

@@ -186,3 +186,51 @@ export async function auditListCommand(options) {
         process.exit(1);
     }
 }
+export async function auditViewCommand(id, options) {
+    const token = await getToken();
+    try {
+        const res = await tokenFetch(token, `/audits/${id}`);
+        if (res.status === 403) {
+            console.error(chalk.red('Access denied. Only Team Managers can view audits.'));
+            process.exit(1);
+        }
+        if (res.status === 404) {
+            console.error(chalk.red(`Audit not found: ${id}`));
+            process.exit(1);
+        }
+        if (!res.ok) {
+            const body = (await res.json());
+            console.error(chalk.red(`Failed to fetch audit: ${body.error ?? res.statusText}`));
+            process.exit(1);
+        }
+        const audit = (await res.json());
+        if (options.output) {
+            const outputPath = path.resolve(options.output);
+            await fs.ensureDir(path.dirname(outputPath));
+            await fs.writeFile(outputPath, audit.content, 'utf-8');
+            console.log(chalk.green(`\n  ✓ Audit saved to ${path.relative(process.cwd(), outputPath)}\n`));
+        }
+        else {
+            const typeLabels = {
+                audit: 'Tech Audit',
+                'ux-audit': 'UX Audit',
+                'security-audit': 'Security Audit',
+            };
+            const label = typeLabels[audit.type] ?? audit.type;
+            const date = new Date(audit.createdAt).toLocaleDateString('en-US', {
+                month: 'short',
+                day: 'numeric',
+                year: 'numeric',
+            });
+            const repo = audit.repository ?? audit.project;
+            console.log();
+            console.log(chalk.dim(`  ${label} · ${repo} · ${audit.author} · ${date}`));
+            console.log();
+            console.log(audit.content);
+        }
+    }
+    catch (error) {
+        console.error(chalk.red(`Failed to fetch audit: ${error instanceof Error ? error.message : 'Unknown error'}`));
+        process.exit(1);
+    }
+}

package/dist/commands/audit.test.d.ts

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

package/dist/commands/audit.test.js

@@ -0,0 +1,322 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+vi.mock('fs-extra', () => ({
+    default: {
+        pathExists: vi.fn(),
+        readFile: vi.fn(),
+    },
+}));
+vi.mock('../utils/api.js', () => ({
+    getToken: vi.fn(),
+    tokenFetch: vi.fn(),
+}));
+vi.mock('../utils/git.js', () => ({
+    getGitBranch: vi.fn(),
+    getGitCommit: vi.fn(),
+    getGitRepository: vi.fn(),
+    getProjectName: vi.fn(),
+    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 } from './audit.js';
+beforeEach(() => {
+    vi.clearAllMocks();
+    vi.spyOn(console, 'log').mockImplementation(() => { });
+    vi.spyOn(console, 'error').mockImplementation(() => { });
+    vi.spyOn(process, 'exit').mockImplementation((code) => {
+        throw new Error(`process.exit(${code})`);
+    });
+});
+describe('auditSubmitCommand', () => {
+    function setupGitMocks() {
+        ;
+        getToken.mockResolvedValue('test-token');
+        getGitBranch.mockReturnValue('main');
+        getGitCommit.mockReturnValue('abc1234');
+        getGitRepository.mockReturnValue({
+            slug: 'Org/Repo',
+            url: 'https://github.com/Org/Repo.git',
+        });
+        getProjectName.mockReturnValue('test-project');
+    }
+    it('submits audit with type "security-audit" when filename contains security-audit', async () => {
+        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);
+        await auditSubmitCommand('2026-03-26-security-audit.md');
+        expect(tokenFetch).toHaveBeenCalledWith('test-token', '/audits', expect.objectContaining({
+            method: 'POST',
+            body: expect.stringContaining('"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);
+        await auditSubmitCommand('UX-AUDIT.md');
+        expect(tokenFetch).toHaveBeenCalledWith('test-token', '/audits', expect.objectContaining({
+            method: 'POST',
+            body: expect.stringContaining('"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);
+        await auditSubmitCommand('AUDIT.md');
+        expect(tokenFetch).toHaveBeenCalledWith('test-token', '/audits', expect.objectContaining({
+            method: 'POST',
+            body: expect.stringContaining('"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);
+        await auditSubmitCommand('random-file.md');
+        expect(tokenFetch).toHaveBeenCalledWith('test-token', '/audits', expect.objectContaining({
+            method: 'POST',
+            body: expect.stringContaining('"type":"audit"'),
+        }));
+    });
+    it('exits with error when file not found', async () => {
+        setupGitMocks();
+        fs.pathExists.mockResolvedValue(false);
+        await expect(auditSubmitCommand('nonexistent.md')).rejects.toThrow('process.exit(1)');
+        expect(console.error).toHaveBeenCalled();
+    });
+    it('sends correct payload fields', async () => {
+        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);
+        await auditSubmitCommand('AUDIT.md');
+        const call = tokenFetch.mock.calls[0];
+        const body = JSON.parse(call[2].body);
+        expect(body).toEqual({
+            type: 'audit',
+            project: 'test-project',
+            repository: 'Org/Repo',
+            repositoryUrl: 'https://github.com/Org/Repo.git',
+            branch: 'main',
+            commit: 'abc1234',
+            content: 'audit content here',
+            metadata: { filename: 'AUDIT.md' },
+        });
+    });
+    it('exits with error when API returns failure', async () => {
+        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);
+        await expect(auditSubmitCommand('AUDIT.md')).rejects.toThrow('process.exit(1)');
+    });
+    it('auto-detects audit file from .audits/ directory when no file provided', async () => {
+        setupGitMocks();
+        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);
+        await auditSubmitCommand();
+        expect(tokenFetch).toHaveBeenCalledWith('test-token', '/audits', expect.objectContaining({
+            method: 'POST',
+            body: expect.stringContaining('"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)');
+        expect(console.error).toHaveBeenCalled();
+    });
+});
+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);
+        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');
+    });
+    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);
+        await auditListCommand({ latest: true });
+        const url = tokenFetch.mock.calls[0][1];
+        expect(url).toContain('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);
+        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);
+        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);
+        await auditListCommand({ latest: true });
+        const logCalls = console.log.mock.calls.map((c) => String(c[0]));
+        // Should display "Latest Audits" header
+        expect(logCalls.some((msg) => msg.includes('Latest Audits'))).toBe(true);
+        // 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'));
+        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);
+        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);
+    });
+});

package/dist/commands/coins.test.d.ts

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

package/dist/commands/coins.test.js

@@ -0,0 +1,133 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+vi.mock('../utils/auth.js', () => ({
+    isAuthenticated: vi.fn(),
+    authenticatedFetch: vi.fn(),
+}));
+import { isAuthenticated, authenticatedFetch } from '../utils/auth.js';
+import { coinsCommand } from './coins.js';
+beforeEach(() => {
+    vi.clearAllMocks();
+    vi.spyOn(console, 'log').mockImplementation(() => { });
+    vi.spyOn(console, 'error').mockImplementation(() => { });
+    vi.spyOn(process, 'exit').mockImplementation((code) => {
+        throw new Error(`process.exit(${code})`);
+    });
+});
+describe('coinsCommand', () => {
+    describe('balance (default)', () => {
+        it('exits with error when not authenticated', async () => {
+            ;
+            isAuthenticated.mockResolvedValue(false);
+            await expect(coinsCommand({})).rejects.toThrow('process.exit(1)');
+            expect(console.error).toHaveBeenCalled();
+        });
+        it('displays coin balance on success', async () => {
+            ;
+            isAuthenticated.mockResolvedValue(true);
+            const mockResponse = {
+                ok: true,
+                json: vi.fn().mockResolvedValue({ coins: 5, period: '28d' }),
+            };
+            authenticatedFetch.mockResolvedValue(mockResponse);
+            await coinsCommand({});
+            expect(authenticatedFetch).toHaveBeenCalledWith('/coins');
+            const logCalls = console.log.mock.calls.map((c) => String(c[0]));
+            expect(logCalls.some((msg) => msg.includes('5'))).toBe(true);
+        });
+        it('displays singular coin text for 1 coin', async () => {
+            ;
+            isAuthenticated.mockResolvedValue(true);
+            authenticatedFetch.mockResolvedValue({
+                ok: true,
+                json: vi.fn().mockResolvedValue({ coins: 1, period: '28d' }),
+            });
+            await coinsCommand({});
+            const logCalls = console.log.mock.calls.map((c) => String(c[0]));
+            expect(logCalls.some((msg) => msg.includes('coin') && !msg.includes('coins'))).toBe(true);
+        });
+        it('displays plural coin text for multiple coins', async () => {
+            ;
+            isAuthenticated.mockResolvedValue(true);
+            authenticatedFetch.mockResolvedValue({
+                ok: true,
+                json: vi.fn().mockResolvedValue({ coins: 3, period: '28d' }),
+            });
+            await coinsCommand({});
+            const logCalls = console.log.mock.calls.map((c) => String(c[0]));
+            expect(logCalls.some((msg) => msg.includes('coins'))).toBe(true);
+        });
+        it('exits with error when API returns failure', async () => {
+            ;
+            isAuthenticated.mockResolvedValue(true);
+            const mockResponse = {
+                ok: false,
+                statusText: 'Internal Server Error',
+                json: vi.fn().mockResolvedValue({ error: 'Something went wrong' }),
+            };
+            authenticatedFetch.mockResolvedValue(mockResponse);
+            await expect(coinsCommand({})).rejects.toThrow('process.exit(1)');
+            const errorCalls = console.error.mock.calls.map((c) => String(c[0]));
+            expect(errorCalls.some((msg) => msg.includes('Something went wrong'))).toBe(true);
+        });
+    });
+    describe('leaderboard', () => {
+        it('exits with error when not authenticated', async () => {
+            ;
+            isAuthenticated.mockResolvedValue(false);
+            await expect(coinsCommand({ leaderboard: true })).rejects.toThrow('process.exit(1)');
+        });
+        it('displays leaderboard entries on success', async () => {
+            ;
+            isAuthenticated.mockResolvedValue(true);
+            const entries = [
+                { name: 'Alice', coins: 10 },
+                { name: 'Bob', coins: 7 },
+                { name: 'Charlie', coins: 3 },
+            ];
+            authenticatedFetch.mockResolvedValue({
+                ok: true,
+                json: vi.fn().mockResolvedValue(entries),
+            });
+            await coinsCommand({ leaderboard: true });
+            expect(authenticatedFetch).toHaveBeenCalledWith('/coins/leaderboard');
+            const logCalls = console.log.mock.calls.map((c) => String(c[0]));
+            expect(logCalls.some((msg) => msg.includes('Leaderboard'))).toBe(true);
+            expect(logCalls.some((msg) => msg.includes('Alice'))).toBe(true);
+            expect(logCalls.some((msg) => msg.includes('Bob'))).toBe(true);
+        });
+        it('shows message when no coins have been sent', async () => {
+            ;
+            isAuthenticated.mockResolvedValue(true);
+            authenticatedFetch.mockResolvedValue({
+                ok: true,
+                json: vi.fn().mockResolvedValue([]),
+            });
+            await coinsCommand({ leaderboard: true });
+            const logCalls = console.log.mock.calls.map((c) => String(c[0]));
+            expect(logCalls.some((msg) => msg.includes('No coins'))).toBe(true);
+        });
+        it('exits with error when leaderboard API fails', async () => {
+            ;
+            isAuthenticated.mockResolvedValue(true);
+            authenticatedFetch.mockResolvedValue({
+                ok: false,
+                statusText: 'Forbidden',
+                json: vi.fn().mockResolvedValue({ error: 'Access denied' }),
+            });
+            await expect(coinsCommand({ leaderboard: true })).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('calls /coins/leaderboard endpoint not /coins', async () => {
+            ;
+            isAuthenticated.mockResolvedValue(true);
+            authenticatedFetch.mockResolvedValue({
+                ok: true,
+                json: vi.fn().mockResolvedValue([{ name: 'Test', coins: 1 }]),
+            });
+            await coinsCommand({ leaderboard: true });
+            expect(authenticatedFetch).toHaveBeenCalledWith('/coins/leaderboard');
+            expect(authenticatedFetch).not.toHaveBeenCalledWith('/coins');
+        });
+    });
+});

package/dist/commands/feedback.test.d.ts

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