@meltstudio/meltctl 4.35.0 → 4.36.0

package/dist/commands/standup.test.js

@@ -1,13 +1,21 @@
 import { describe, it, expect, vi, beforeEach } from 'vitest';
 vi.mock('../utils/auth.js', () => ({
     isAuthenticated: vi.fn(),
-    authenticatedFetch: vi.fn(),
+}));
+const mockClient = vi.hoisted(() => ({
+    standups: {
+        getStatus: vi.fn(),
+        submit: vi.fn(),
+    },
+}));
+vi.mock('../utils/api.js', () => ({
+    getClient: vi.fn().mockResolvedValue(mockClient),
 }));
 vi.mock('@inquirer/prompts', () => ({
     input: vi.fn(),
     editor: vi.fn(),
 }));
-import { isAuthenticated, authenticatedFetch } from '../utils/auth.js';
+import { isAuthenticated } from '../utils/auth.js';
 import { input, editor } from '@inquirer/prompts';
 import { standupCommand } from './standup.js';
 beforeEach(() => {
@@ -28,47 +36,33 @@ describe('standupCommand', () => {
     it('returns early when standup already submitted today', async () => {
         ;
         isAuthenticated.mockResolvedValue(true);
-        const statusResponse = {
-            ok: true,
-            json: vi.fn().mockResolvedValue({
-                yesterday: 'Did stuff',
-                today: 'More stuff',
-                blockers: null,
-            }),
-        };
-        authenticatedFetch.mockResolvedValue(statusResponse);
+        mockClient.standups.getStatus.mockResolvedValue({
+            yesterday: 'Did stuff',
+            today: 'More stuff',
+            blockers: null,
+        });
         await standupCommand({});
-        expect(authenticatedFetch).toHaveBeenCalledWith('/standups/status');
-        // Should not call POST /standups
-        expect(authenticatedFetch).toHaveBeenCalledTimes(1);
+        expect(mockClient.standups.getStatus).toHaveBeenCalled();
+        // Should not call submit
+        expect(mockClient.standups.submit).not.toHaveBeenCalled();
         const logCalls = console.log.mock.calls.map((c) => String(c[0]));
         expect(logCalls.some((msg) => msg.includes('already submitted'))).toBe(true);
     });
     it('submits standup with correct payload using option flags', async () => {
         ;
         isAuthenticated.mockResolvedValue(true);
-        // Status check returns not found (no existing standup)
-        const statusResponse = { ok: false };
-        const submitResponse = {
-            ok: true,
-            json: vi.fn().mockResolvedValue({}),
-        };
-        authenticatedFetch
-            .mockResolvedValueOnce(statusResponse)
-            .mockResolvedValueOnce(submitResponse);
+        // Status check returns null (no existing standup)
+        mockClient.standups.getStatus.mockResolvedValue(null);
+        mockClient.standups.submit.mockResolvedValue({});
         await standupCommand({
             yesterday: 'Fixed bugs',
             today: 'Write tests',
             blockers: 'None',
         });
-        expect(authenticatedFetch).toHaveBeenCalledWith('/standups', {
-            method: 'POST',
-            headers: { 'Content-Type': 'application/json' },
-            body: JSON.stringify({
-                yesterday: 'Fixed bugs',
-                today: 'Write tests',
-                blockers: 'None',
-            }),
+        expect(mockClient.standups.submit).toHaveBeenCalledWith({
+            yesterday: 'Fixed bugs',
+            today: 'Write tests',
+            blockers: 'None',
         });
         const logCalls = console.log.mock.calls.map((c) => String(c[0]));
         expect(logCalls.some((msg) => msg.includes('Standup submitted'))).toBe(true);
@@ -76,58 +70,45 @@ describe('standupCommand', () => {
     it('submits standup without blockers when empty string', async () => {
         ;
         isAuthenticated.mockResolvedValue(true);
-        const statusResponse = { ok: false };
-        const submitResponse = { ok: true, json: vi.fn().mockResolvedValue({}) };
-        authenticatedFetch
-            .mockResolvedValueOnce(statusResponse)
-            .mockResolvedValueOnce(submitResponse);
+        mockClient.standups.getStatus.mockResolvedValue(null);
+        mockClient.standups.submit.mockResolvedValue({});
         await standupCommand({
             yesterday: 'Did things',
             today: 'More things',
         });
-        const call = authenticatedFetch.mock.calls[1];
-        const body = JSON.parse(call[1].body);
-        expect(body.blockers).toBeUndefined();
+        expect(mockClient.standups.submit).toHaveBeenCalledWith({
+            yesterday: 'Did things',
+            today: 'More things',
+            blockers: undefined,
+        });
     });
     it('exits with error when API returns failure', async () => {
         ;
         isAuthenticated.mockResolvedValue(true);
-        const statusResponse = { ok: false };
-        const submitResponse = {
-            ok: false,
-            statusText: 'Bad Request',
-            json: vi.fn().mockResolvedValue({ error: 'Invalid standup' }),
-        };
-        authenticatedFetch
-            .mockResolvedValueOnce(statusResponse)
-            .mockResolvedValueOnce(submitResponse);
+        mockClient.standups.getStatus.mockResolvedValue(null);
+        mockClient.standups.submit.mockRejectedValue(new Error('Invalid standup'));
         await expect(standupCommand({ yesterday: 'x', today: 'y' })).rejects.toThrow('process.exit(1)');
         expect(console.error).toHaveBeenCalled();
     });
     it('continues to submission when status check throws', async () => {
         ;
         isAuthenticated.mockResolvedValue(true);
-        authenticatedFetch
-            .mockRejectedValueOnce(new Error('Network error'))
-            .mockResolvedValueOnce({ ok: true, json: vi.fn().mockResolvedValue({}) });
+        mockClient.standups.getStatus.mockRejectedValue(new Error('Network error'));
+        mockClient.standups.submit.mockResolvedValue({});
         await standupCommand({ yesterday: 'a', today: 'b' });
-        expect(authenticatedFetch).toHaveBeenCalledTimes(2);
-        expect(authenticatedFetch).toHaveBeenCalledWith('/standups', expect.objectContaining({
-            method: 'POST',
+        expect(mockClient.standups.submit).toHaveBeenCalledWith(expect.objectContaining({
+            yesterday: 'a',
+            today: 'b',
         }));
     });
     it('displays existing standup with blockers', async () => {
         ;
         isAuthenticated.mockResolvedValue(true);
-        const statusResponse = {
-            ok: true,
-            json: vi.fn().mockResolvedValue({
-                yesterday: 'Bug fixes',
-                today: 'Feature work',
-                blockers: 'Waiting on review',
-            }),
-        };
-        authenticatedFetch.mockResolvedValue(statusResponse);
+        mockClient.standups.getStatus.mockResolvedValue({
+            yesterday: 'Bug fixes',
+            today: 'Feature work',
+            blockers: 'Waiting on review',
+        });
         await standupCommand({});
         const logCalls = console.log.mock.calls.map((c) => String(c[0]));
         expect(logCalls.some((msg) => msg.includes('already submitted'))).toBe(true);
@@ -136,44 +117,41 @@ describe('standupCommand', () => {
         function setupInteractiveAuth() {
             ;
             isAuthenticated.mockResolvedValue(true);
-            authenticatedFetch.mockResolvedValueOnce({ ok: false });
+            // Status check returns null (no existing standup)
+            mockClient.standups.getStatus.mockResolvedValue(null);
         }
         it('prompts for yesterday, today, and blockers in interactive mode', async () => {
             setupInteractiveAuth();
-            const submitResponse = { ok: true, json: vi.fn().mockResolvedValue({}) };
-            authenticatedFetch.mockResolvedValueOnce(submitResponse);
+            mockClient.standups.submit.mockResolvedValue({});
             input
                 .mockResolvedValueOnce('Worked on feature X')
                 .mockResolvedValueOnce('Working on feature Y')
                 .mockResolvedValueOnce('No blockers');
             await standupCommand({});
             expect(input).toHaveBeenCalledTimes(3);
-            expect(authenticatedFetch).toHaveBeenCalledWith('/standups', expect.objectContaining({
-                method: 'POST',
-                body: JSON.stringify({
-                    yesterday: 'Worked on feature X',
-                    today: 'Working on feature Y',
-                    blockers: 'No blockers',
-                }),
-            }));
+            expect(mockClient.standups.submit).toHaveBeenCalledWith({
+                yesterday: 'Worked on feature X',
+                today: 'Working on feature Y',
+                blockers: 'No blockers',
+            });
         });
         it('submits without blockers when left empty in interactive mode', async () => {
             setupInteractiveAuth();
-            const submitResponse = { ok: true, json: vi.fn().mockResolvedValue({}) };
-            authenticatedFetch.mockResolvedValueOnce(submitResponse);
+            mockClient.standups.submit.mockResolvedValue({});
             input
                 .mockResolvedValueOnce('Did code review')
                 .mockResolvedValueOnce('Deploy to staging')
                 .mockResolvedValueOnce('');
             await standupCommand({});
-            const call = authenticatedFetch.mock.calls[1];
-            const body = JSON.parse(call[1].body);
-            expect(body.blockers).toBeUndefined();
+            expect(mockClient.standups.submit).toHaveBeenCalledWith({
+                yesterday: 'Did code review',
+                today: 'Deploy to staging',
+                blockers: undefined,
+            });
         });
         it('re-prompts when required field is empty', async () => {
             setupInteractiveAuth();
-            const submitResponse = { ok: true, json: vi.fn().mockResolvedValue({}) };
-            authenticatedFetch.mockResolvedValueOnce(submitResponse);
+            mockClient.standups.submit.mockResolvedValue({});
             input
                 .mockResolvedValueOnce('  ') // empty yesterday -> re-prompt
                 .mockResolvedValueOnce('Fixed a bug') // valid yesterday
@@ -186,8 +164,7 @@ describe('standupCommand', () => {
         });
         it('opens editor when user types \\e', async () => {
             setupInteractiveAuth();
-            const submitResponse = { ok: true, json: vi.fn().mockResolvedValue({}) };
-            authenticatedFetch.mockResolvedValueOnce(submitResponse);
+            mockClient.standups.submit.mockResolvedValue({});
             input
                 .mockResolvedValueOnce('\\e') // trigger editor for yesterday
                 .mockResolvedValueOnce('Writing docs') // today
@@ -196,14 +173,13 @@ describe('standupCommand', () => {
             editor.mockResolvedValueOnce('Detailed yesterday notes from editor');
             await standupCommand({});
             expect(editor).toHaveBeenCalledTimes(1);
-            const call = authenticatedFetch.mock.calls[1];
-            const body = JSON.parse(call[1].body);
-            expect(body.yesterday).toBe('Detailed yesterday notes from editor');
+            expect(mockClient.standups.submit).toHaveBeenCalledWith(expect.objectContaining({
+                yesterday: 'Detailed yesterday notes from editor',
+            }));
         });
         it('falls back to inline input when editor fails', async () => {
             setupInteractiveAuth();
-            const submitResponse = { ok: true, json: vi.fn().mockResolvedValue({}) };
-            authenticatedFetch.mockResolvedValueOnce(submitResponse);
+            mockClient.standups.submit.mockResolvedValue({});
             input
                 .mockResolvedValueOnce('\\e') // trigger editor for yesterday
                 .mockResolvedValueOnce('Fallback input') // fallback after editor fails
@@ -218,12 +194,7 @@ describe('standupCommand', () => {
         });
         it('exits with error when API fails in interactive mode', async () => {
             setupInteractiveAuth();
-            const submitResponse = {
-                ok: false,
-                statusText: 'Unprocessable Entity',
-                json: vi.fn().mockResolvedValue({ error: 'Missing fields' }),
-            };
-            authenticatedFetch.mockResolvedValueOnce(submitResponse);
+            mockClient.standups.submit.mockRejectedValue(new Error('Missing fields'));
             input
                 .mockResolvedValueOnce('Yesterday work')
                 .mockResolvedValueOnce('Today work')
@@ -234,12 +205,7 @@ describe('standupCommand', () => {
         });
         it('falls back to statusText when API error has no error body', async () => {
             setupInteractiveAuth();
-            const submitResponse = {
-                ok: false,
-                statusText: 'Bad Gateway',
-                json: vi.fn().mockResolvedValue({}),
-            };
-            authenticatedFetch.mockResolvedValueOnce(submitResponse);
+            mockClient.standups.submit.mockRejectedValue(new Error('Bad Gateway'));
             input
                 .mockResolvedValueOnce('Yesterday')
                 .mockResolvedValueOnce('Today')

package/dist/utils/analytics.js

@@ -1,6 +1,7 @@
 import { readFileSync } from 'fs';
 import { join, dirname } from 'path';
 import { fileURLToPath } from 'url';
+import { createMeltClient } from '@meltstudio/meltctl-sdk';
 import { getStoredAuth, API_BASE } from './auth.js';
 import { getGitRepository, getGitBranch, getProjectName } from './git.js';
 import { debugLog } from './debug.js';
@@ -27,15 +28,11 @@ export async function trackCommand(command, success, errorMessage) {
             return;
         }
         const repo = getGitRepository();
+        const client = createMeltClient({ baseUrl: API_BASE, token: auth.token });
         const controller = new AbortController();
         const timeout = setTimeout(() => controller.abort(), 3000);
-        const res = await fetch(`${API_BASE}/events`, {
-            method: 'POST',
-            headers: {
-                Authorization: `Bearer ${auth.token}`,
-                'Content-Type': 'application/json',
-            },
-            body: JSON.stringify({
+        try {
+            await client.events.submit({
                 command,
                 project: getProjectName(),
                 repository: repo?.slug ?? null,
@@ -43,20 +40,13 @@ export async function trackCommand(command, success, errorMessage) {
                 version: getVersion(),
                 success,
                 errorMessage: errorMessage?.slice(0, 500) ?? null,
-            }),
-            signal: controller.signal,
-        }).catch(e => {
-            debugLog(`Analytics fetch failed: ${e instanceof Error ? e.message : e}`);
-            return null;
-        });
-        clearTimeout(timeout);
-        if (res && !res.ok) {
-            const body = await res.text().catch(() => '');
-            debugLog(`Analytics API error ${res.status}: ${body}`);
-        }
-        else if (res) {
+            });
             debugLog(`Analytics event sent for "${command}"`);
         }
+        catch (e) {
+            debugLog(`Analytics error: ${e instanceof Error ? e.message : e}`);
+        }
+        clearTimeout(timeout);
     }
     catch (e) {
         debugLog(`Analytics error: ${e instanceof Error ? e.message : e}`);

package/dist/utils/api.d.ts

@@ -1,2 +1,3 @@
+import { type MeltClient } from '@meltstudio/meltctl-sdk';
 export declare function getToken(): Promise<string>;
-export declare function tokenFetch(token: string, urlPath: string, options?: RequestInit): Promise<Response>;
+export declare function getClient(): Promise<MeltClient>;

package/dist/utils/api.js

@@ -1,4 +1,5 @@
 import chalk from 'chalk';
+import { createMeltClient } from '@meltstudio/meltctl-sdk';
 import { getStoredAuth, API_BASE } from './auth.js';
 export async function getToken() {
     const envToken = process.env['MELTCTL_TOKEN'];
@@ -16,16 +17,7 @@ export async function getToken() {
     }
     return auth.token;
 }
-export async function tokenFetch(token, urlPath, options = {}) {
-    const response = await fetch(`${API_BASE}${urlPath}`, {
-        ...options,
-        headers: {
-            Authorization: `Bearer ${token}`,
-            ...options.headers,
-        },
-    });
-    if (response.status === 401) {
-        throw new Error('Authentication failed. Run `npx @meltstudio/meltctl@latest login` or check your MELTCTL_TOKEN.');
-    }
-    return response;
+export async function getClient() {
+    const token = await getToken();
+    return createMeltClient({ baseUrl: API_BASE, token });
 }

package/dist/utils/api.test.js

@@ -3,8 +3,12 @@ vi.mock('./auth.js', () => ({
     getStoredAuth: vi.fn(),
     API_BASE: 'https://test-api.example.com',
 }));
-import { getStoredAuth, API_BASE } from './auth.js';
-import { getToken, tokenFetch } from './api.js';
+vi.mock('@meltstudio/meltctl-sdk', () => ({
+    createMeltClient: vi.fn().mockReturnValue({ mock: true }),
+}));
+import { getStoredAuth } from './auth.js';
+import { createMeltClient } from '@meltstudio/meltctl-sdk';
+import { getToken, getClient } from './api.js';
 beforeEach(() => {
     vi.clearAllMocks();
     vi.spyOn(console, 'error').mockImplementation(() => { });
@@ -47,50 +51,26 @@ describe('getToken', () => {
         expect(console.error).toHaveBeenCalled();
     });
 });
-describe('tokenFetch', () => {
-    it('makes request with bearer token', async () => {
-        const mockResponse = { status: 200, ok: true };
-        const fetchMock = vi.fn().mockResolvedValue(mockResponse);
-        vi.stubGlobal('fetch', fetchMock);
-        const result = await tokenFetch('my-token', '/audits');
-        expect(result).toBe(mockResponse);
-        expect(fetchMock).toHaveBeenCalledWith(`${API_BASE}/audits`, expect.objectContaining({
-            headers: expect.objectContaining({
-                Authorization: 'Bearer my-token',
-            }),
-        }));
-        vi.unstubAllGlobals();
-    });
-    it('merges custom options and headers', async () => {
-        const fetchMock = vi.fn().mockResolvedValue({ status: 200, ok: true });
-        vi.stubGlobal('fetch', fetchMock);
-        await tokenFetch('tok', '/test', {
-            method: 'POST',
-            headers: { 'Content-Type': 'application/json' },
-            body: '{}',
+describe('getClient', () => {
+    it('creates SDK client with token and base URL', async () => {
+        ;
+        getStoredAuth.mockResolvedValue({
+            token: 'my-token',
+            email: 'dev@meltstudio.co',
+            expiresAt: '2099-12-31T00:00:00Z',
+        });
+        await getClient();
+        expect(createMeltClient).toHaveBeenCalledWith({
+            baseUrl: 'https://test-api.example.com',
+            token: 'my-token',
         });
-        expect(fetchMock).toHaveBeenCalledWith(`${API_BASE}/test`, expect.objectContaining({
-            method: 'POST',
-            body: '{}',
-            headers: expect.objectContaining({
-                Authorization: 'Bearer tok',
-                'Content-Type': 'application/json',
-            }),
-        }));
-        vi.unstubAllGlobals();
-    });
-    it('throws when API returns 401', async () => {
-        const fetchMock = vi.fn().mockResolvedValue({ status: 401, ok: false });
-        vi.stubGlobal('fetch', fetchMock);
-        await expect(tokenFetch('bad-token', '/test')).rejects.toThrow('Authentication failed');
-        vi.unstubAllGlobals();
     });
-    it('returns response for non-401 errors without throwing', async () => {
-        const mockResponse = { status: 500, ok: false, statusText: 'Internal Server Error' };
-        const fetchMock = vi.fn().mockResolvedValue(mockResponse);
-        vi.stubGlobal('fetch', fetchMock);
-        const result = await tokenFetch('tok', '/test');
-        expect(result.status).toBe(500);
-        vi.unstubAllGlobals();
+    it('uses env token when MELTCTL_TOKEN is set', async () => {
+        process.env['MELTCTL_TOKEN'] = 'env-token';
+        await getClient();
+        expect(createMeltClient).toHaveBeenCalledWith({
+            baseUrl: 'https://test-api.example.com',
+            token: 'env-token',
+        });
     });
 });

package/dist/utils/templates.d.ts

@@ -1,4 +1,2 @@
-export interface TemplateFiles {
-    [key: string]: string;
-}
-export declare function fetchTemplates(): Promise<TemplateFiles>;
+export type { TemplateFiles } from '@meltstudio/meltctl-sdk';
+export declare function fetchTemplates(): Promise<Record<string, string>>;

package/dist/utils/templates.js

@@ -1,9 +1,5 @@
-import { authenticatedFetch } from './auth.js';
+import { getClient } from './api.js';
 export async function fetchTemplates() {
-    const response = await authenticatedFetch('/templates');
-    if (!response.ok) {
-        throw new Error(`Failed to fetch templates: ${response.statusText}`);
-    }
-    const data = (await response.json());
-    return data.files;
+    const client = await getClient();
+    return client.templates.fetch();
 }

package/dist/utils/templates.test.js

@@ -1,8 +1,12 @@
 import { describe, it, expect, vi, beforeEach } from 'vitest';
-vi.mock('./auth.js', () => ({
-    authenticatedFetch: vi.fn(),
+const mockClient = vi.hoisted(() => ({
+    templates: {
+        fetch: vi.fn(),
+    },
+}));
+vi.mock('./api.js', () => ({
+    getClient: vi.fn().mockResolvedValue(mockClient),
 }));
-import { authenticatedFetch } from './auth.js';
 import { fetchTemplates } from './templates.js';
 beforeEach(() => {
     vi.clearAllMocks();
@@ -13,38 +17,22 @@ describe('fetchTemplates', () => {
             'AGENTS.md': '# Agents content',
             '.claude/skills/setup.md': '# Setup skill',
         };
-        authenticatedFetch.mockResolvedValue({
-            ok: true,
-            json: vi.fn().mockResolvedValue({ files: mockFiles }),
-        });
+        mockClient.templates.fetch.mockResolvedValue(mockFiles);
         const result = await fetchTemplates();
-        expect(authenticatedFetch).toHaveBeenCalledWith('/templates');
+        expect(mockClient.templates.fetch).toHaveBeenCalled();
         expect(result).toEqual(mockFiles);
     });
     it('throws error when API returns failure', async () => {
-        ;
-        authenticatedFetch.mockResolvedValue({
-            ok: false,
-            statusText: 'Unauthorized',
-        });
+        mockClient.templates.fetch.mockRejectedValue(new Error('Failed to fetch templates: 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',
-        });
+        mockClient.templates.fetch.mockRejectedValue(new Error('Failed to fetch templates: 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: {} }),
-        });
+    it('calls client.templates.fetch', async () => {
+        mockClient.templates.fetch.mockResolvedValue({});
         await fetchTemplates();
-        expect(authenticatedFetch).toHaveBeenCalledTimes(1);
-        expect(authenticatedFetch).toHaveBeenCalledWith('/templates');
+        expect(mockClient.templates.fetch).toHaveBeenCalledTimes(1);
     });
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@meltstudio/meltctl",
-  "version": "4.35.0",
+  "version": "4.36.0",
   "description": "AI-first development tools for teams - set up AGENTS.md, Claude Code, Cursor, and OpenCode standards",
   "main": "dist/index.js",
   "type": "module",
@@ -47,6 +47,7 @@
   "author": "Melt Studio",
   "license": "UNLICENSED",
   "dependencies": {
+    "@meltstudio/meltctl-sdk": "*",
     "@commander-js/extra-typings": "^12.1.0",
     "@inquirer/prompts": "^8.2.1",
     "chalk": "^5.4.1",
@@ -60,7 +61,7 @@
     "@typescript-eslint/eslint-plugin": "^8.19.0",
     "@typescript-eslint/parser": "^8.19.0",
     "eslint": "^9.17.0",
-    "eslint-config-prettier": "^9.1.0",
+    "eslint-config-prettier": "^10.1.8",
     "eslint-plugin-prettier": "^5.2.1",
     "prettier": "^3.4.2",
     "tsx": "^4.19.5",