@meltstudio/meltctl 4.34.0 → 4.36.0

package/dist/commands/plan.test.js

@@ -5,9 +5,14 @@ vi.mock('fs-extra', () => ({
         readFile: vi.fn(),
     },
 }));
+const mockClient = vi.hoisted(() => ({
+    plans: {
+        submit: vi.fn(),
+        list: 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(),
@@ -18,7 +23,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, extractTicketId, findMdFiles, } from '../utils/git.js';
 import { planSubmitCommand, planListCommand } from './plan.js';
 beforeEach(() => {
@@ -32,7 +36,6 @@ beforeEach(() => {
 describe('planSubmitCommand', () => {
     function setupGitMocks() {
         ;
-        getToken.mockResolvedValue('test-token');
         getGitBranch.mockReturnValue('feature/PROJ-123-add-feature');
         getGitCommit.mockReturnValue('def5678');
         getGitRepository.mockReturnValue({
@@ -46,15 +49,14 @@ describe('planSubmitCommand', () => {
         setupGitMocks();
         fs.pathExists.mockResolvedValue(true);
         fs.readFile.mockResolvedValue('# Plan\nSome plan content.');
-        const mockResponse = {
-            ok: true,
-            json: vi.fn().mockResolvedValue({ id: 'plan-100', created: true }),
-        };
-        tokenFetch.mockResolvedValue(mockResponse);
+        mockClient.plans.submit.mockResolvedValue({
+            id: 'plan-100',
+            createdAt: '2026-03-26T00:00:00Z',
+            updatedAt: '2026-03-26T00:00:00Z',
+            created: true,
+        });
         await planSubmitCommand('PROJ-123-plan.md');
-        const call = tokenFetch.mock.calls[0];
-        const body = JSON.parse(call[2].body);
-        expect(body).toEqual({
+        expect(mockClient.plans.submit).toHaveBeenCalledWith({
             project: 'test-project',
             repository: 'Org/Repo',
             repositoryUrl: 'https://github.com/Org/Repo.git',
@@ -63,17 +65,19 @@ describe('planSubmitCommand', () => {
             content: '# Plan\nSome plan content.',
             metadata: { filename: 'PROJ-123-plan.md' },
             ticket: 'PROJ-123',
+            status: null,
         });
     });
     it('logs "Plan submitted" when API returns created: true', async () => {
         setupGitMocks();
         fs.pathExists.mockResolvedValue(true);
         fs.readFile.mockResolvedValue('plan content');
-        const mockResponse = {
-            ok: true,
-            json: vi.fn().mockResolvedValue({ id: 'plan-new', created: true }),
-        };
-        tokenFetch.mockResolvedValue(mockResponse);
+        mockClient.plans.submit.mockResolvedValue({
+            id: 'plan-new',
+            createdAt: '2026-03-26T00:00:00Z',
+            updatedAt: '2026-03-26T00:00:00Z',
+            created: true,
+        });
         await planSubmitCommand('plan.md');
         const logCalls = console.log.mock.calls.map((c) => c[0]);
         expect(logCalls.some((msg) => typeof msg === 'string' && msg.includes('Plan submitted'))).toBe(true);
@@ -82,11 +86,12 @@ describe('planSubmitCommand', () => {
         setupGitMocks();
         fs.pathExists.mockResolvedValue(true);
         fs.readFile.mockResolvedValue('updated plan content');
-        const mockResponse = {
-            ok: true,
-            json: vi.fn().mockResolvedValue({ id: 'plan-upd', created: false }),
-        };
-        tokenFetch.mockResolvedValue(mockResponse);
+        mockClient.plans.submit.mockResolvedValue({
+            id: 'plan-upd',
+            createdAt: '2026-03-26T00:00:00Z',
+            updatedAt: '2026-03-26T00:00:00Z',
+            created: false,
+        });
         await planSubmitCommand('plan.md');
         const logCalls = console.log.mock.calls.map((c) => c[0]);
         expect(logCalls.some((msg) => typeof msg === 'string' && msg.includes('Plan updated'))).toBe(true);
@@ -101,12 +106,7 @@ describe('planSubmitCommand', () => {
         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.plans.submit.mockRejectedValue(new Error('Invalid content'));
         await expect(planSubmitCommand('plan.md')).rejects.toThrow('process.exit(1)');
     });
     it('auto-detects plan file from .plans/ directory when no file provided', async () => {
@@ -115,19 +115,19 @@ describe('planSubmitCommand', () => {
         extractTicketId.mockReturnValue('PROJ-123');
         fs.pathExists.mockResolvedValue(true);
         fs.readFile.mockResolvedValue('auto-detected plan');
-        const mockResponse = {
-            ok: true,
-            json: vi.fn().mockResolvedValue({ id: 'plan-auto', created: true }),
-        };
-        tokenFetch.mockResolvedValue(mockResponse);
+        mockClient.plans.submit.mockResolvedValue({
+            id: 'plan-auto',
+            createdAt: '2026-03-26T00:00:00Z',
+            updatedAt: '2026-03-26T00:00:00Z',
+            created: true,
+        });
         await planSubmitCommand();
-        expect(tokenFetch).toHaveBeenCalledWith('test-token', '/plans', expect.objectContaining({
-            method: 'POST',
+        expect(mockClient.plans.submit).toHaveBeenCalledWith(expect.objectContaining({
+            content: 'auto-detected plan',
         }));
     });
     it('exits with error when no file provided and none auto-detected', async () => {
         ;
-        getToken.mockResolvedValue('test-token');
         findMdFiles.mockResolvedValue([]);
         getGitBranch.mockReturnValue('main');
         extractTicketId.mockReturnValue(null);
@@ -136,7 +136,6 @@ describe('planSubmitCommand', () => {
     });
     it('does not include ticket in payload when extractTicketId returns null', async () => {
         ;
-        getToken.mockResolvedValue('test-token');
         getGitBranch.mockReturnValue('main');
         getGitCommit.mockReturnValue('abc1234');
         getGitRepository.mockReturnValue({
@@ -147,137 +146,101 @@ describe('planSubmitCommand', () => {
         extractTicketId.mockReturnValue(null);
         fs.pathExists.mockResolvedValue(true);
         fs.readFile.mockResolvedValue('plan without ticket');
-        const mockResponse = {
-            ok: true,
-            json: vi.fn().mockResolvedValue({ id: 'plan-no-ticket', created: true }),
-        };
-        tokenFetch.mockResolvedValue(mockResponse);
+        mockClient.plans.submit.mockResolvedValue({
+            id: 'plan-no-ticket',
+            createdAt: '2026-03-26T00:00:00Z',
+            updatedAt: '2026-03-26T00:00:00Z',
+            created: true,
+        });
         await planSubmitCommand('plan.md');
-        const call = tokenFetch.mock.calls[0];
-        const body = JSON.parse(call[2].body);
-        expect(body.ticket).toBeUndefined();
+        expect(mockClient.plans.submit).toHaveBeenCalledWith(expect.objectContaining({
+            ticket: null,
+        }));
     });
     it('includes status from frontmatter when present', async () => {
         setupGitMocks();
         fs.pathExists.mockResolvedValue(true);
         fs.readFile.mockResolvedValue('---\nstatus: approved\n---\n# Plan');
-        const mockResponse = {
-            ok: true,
-            json: vi.fn().mockResolvedValue({ id: 'plan-status', created: true }),
-        };
-        tokenFetch.mockResolvedValue(mockResponse);
+        mockClient.plans.submit.mockResolvedValue({
+            id: 'plan-status',
+            createdAt: '2026-03-26T00:00:00Z',
+            updatedAt: '2026-03-26T00:00:00Z',
+            created: true,
+        });
         await planSubmitCommand('plan.md');
-        const call = tokenFetch.mock.calls[0];
-        const body = JSON.parse(call[2].body);
-        expect(body.status).toBe('approved');
+        expect(mockClient.plans.submit).toHaveBeenCalledWith(expect.objectContaining({
+            status: 'approved',
+        }));
     });
     it('does not include status when no frontmatter present', async () => {
         setupGitMocks();
         fs.pathExists.mockResolvedValue(true);
         fs.readFile.mockResolvedValue('# Plan\nNo frontmatter here.');
-        const mockResponse = {
-            ok: true,
-            json: vi.fn().mockResolvedValue({ id: 'plan-no-status', created: true }),
-        };
-        tokenFetch.mockResolvedValue(mockResponse);
+        mockClient.plans.submit.mockResolvedValue({
+            id: 'plan-no-status',
+            createdAt: '2026-03-26T00:00:00Z',
+            updatedAt: '2026-03-26T00:00:00Z',
+            created: true,
+        });
         await planSubmitCommand('plan.md');
-        const call = tokenFetch.mock.calls[0];
-        const body = JSON.parse(call[2].body);
-        expect(body.status).toBeUndefined();
+        expect(mockClient.plans.submit).toHaveBeenCalledWith(expect.objectContaining({
+            status: null,
+        }));
     });
 });
 describe('planListCommand', () => {
     it('calls API with correct query params', async () => {
-        ;
-        getToken.mockResolvedValue('test-token');
-        const mockResponse = {
-            ok: true,
-            status: 200,
-            json: vi.fn().mockResolvedValue({ plans: [], count: 0 }),
-        };
-        tokenFetch.mockResolvedValue(mockResponse);
+        mockClient.plans.list.mockResolvedValue({ plans: [], count: 0 });
         await planListCommand({ repository: 'Org/Repo', author: 'dev@meltstudio.co', limit: '5' });
-        expect(tokenFetch).toHaveBeenCalledWith('test-token', expect.stringContaining('/plans?'));
-        const url = tokenFetch.mock.calls[0][1];
-        expect(url).toContain('repository=Org%2FRepo');
-        expect(url).toContain('author=dev%40meltstudio.co');
-        expect(url).toContain('limit=5');
+        expect(mockClient.plans.list).toHaveBeenCalledWith({
+            repository: 'Org/Repo',
+            author: 'dev@meltstudio.co',
+            limit: 5,
+        });
     });
     it('exits with error on 403 response', async () => {
-        ;
-        getToken.mockResolvedValue('test-token');
-        const mockResponse = {
-            ok: false,
-            status: 403,
-            statusText: 'Forbidden',
-        };
-        tokenFetch.mockResolvedValue(mockResponse);
+        mockClient.plans.list.mockRejectedValue(new Error('Access denied. Only Team Managers can list plans.'));
         await expect(planListCommand({})).rejects.toThrow('process.exit(1)');
         expect(console.error).toHaveBeenCalled();
     });
     it('displays plan list when plans exist', async () => {
-        ;
-        getToken.mockResolvedValue('test-token');
-        const mockResponse = {
-            ok: true,
-            status: 200,
-            json: vi.fn().mockResolvedValue({
-                plans: [
-                    {
-                        id: '1',
-                        project: 'my-project',
-                        repository: 'Org/Repo',
-                        author: 'dev@meltstudio.co',
-                        branch: 'feature/PROJ-123',
-                        commit: 'abc1234',
-                        ticket: 'PROJ-123',
-                        status: 'submitted',
-                        createdAt: '2026-03-25T10:00:00Z',
-                        updatedAt: '2026-03-25T12:00:00Z',
-                    },
-                ],
-                count: 1,
-            }),
-        };
-        tokenFetch.mockResolvedValue(mockResponse);
+        mockClient.plans.list.mockResolvedValue({
+            plans: [
+                {
+                    id: '1',
+                    project: 'my-project',
+                    repository: 'Org/Repo',
+                    author: 'dev@meltstudio.co',
+                    branch: 'feature/PROJ-123',
+                    commit: 'abc1234',
+                    ticket: 'PROJ-123',
+                    status: 'submitted',
+                    createdAt: '2026-03-25T10:00:00Z',
+                    updatedAt: '2026-03-25T12:00:00Z',
+                },
+            ],
+            count: 1,
+        });
         await planListCommand({});
         expect(console.log).toHaveBeenCalled();
     });
     it('shows "No plans found" when list is empty', async () => {
-        ;
-        getToken.mockResolvedValue('test-token');
-        const mockResponse = {
-            ok: true,
-            status: 200,
-            json: vi.fn().mockResolvedValue({ plans: [], count: 0 }),
-        };
-        tokenFetch.mockResolvedValue(mockResponse);
+        mockClient.plans.list.mockResolvedValue({ plans: [], count: 0 });
         await planListCommand({});
         const logCalls = console.log.mock.calls.map((c) => c[0]);
         expect(logCalls.some((msg) => typeof msg === 'string' && msg.includes('No plans found'))).toBe(true);
     });
     it('calls API without query params when no options provided', async () => {
-        ;
-        getToken.mockResolvedValue('test-token');
-        const mockResponse = {
-            ok: true,
-            status: 200,
-            json: vi.fn().mockResolvedValue({ plans: [], count: 0 }),
-        };
-        tokenFetch.mockResolvedValue(mockResponse);
+        mockClient.plans.list.mockResolvedValue({ plans: [], count: 0 });
         await planListCommand({});
-        expect(tokenFetch).toHaveBeenCalledWith('test-token', '/plans');
+        expect(mockClient.plans.list).toHaveBeenCalledWith({
+            repository: undefined,
+            author: undefined,
+            limit: undefined,
+        });
     });
     it('exits with error on non-403 failure response', async () => {
-        ;
-        getToken.mockResolvedValue('test-token');
-        const mockResponse = {
-            ok: false,
-            status: 500,
-            statusText: 'Internal Server Error',
-            json: vi.fn().mockResolvedValue({ error: 'Server error' }),
-        };
-        tokenFetch.mockResolvedValue(mockResponse);
+        mockClient.plans.list.mockRejectedValue(new Error('Server error'));
         await expect(planListCommand({})).rejects.toThrow('process.exit(1)');
     });
 });

package/dist/commands/standup.js

@@ -1,6 +1,7 @@
 import chalk from 'chalk';
 import { input, editor } from '@inquirer/prompts';
-import { isAuthenticated, authenticatedFetch } from '../utils/auth.js';
+import { isAuthenticated } from '../utils/auth.js';
+import { getClient } from '../utils/api.js';
 const EDITOR_HINT = chalk.dim('(type \\e to open your editor)');
 async function promptField(message, required) {
     const value = await input({ message: `${message} ${EDITOR_HINT}` });
@@ -24,11 +25,11 @@ export async function standupCommand(options) {
         console.error(chalk.red('Not authenticated. Run `npx @meltstudio/meltctl@latest login` first.'));
         process.exit(1);
     }
+    const client = await getClient();
     // Check if already submitted today
     try {
-        const statusRes = await authenticatedFetch('/standups/status');
-        if (statusRes.ok) {
-            const existing = (await statusRes.json());
+        const existing = await client.standups.getStatus();
+        if (existing) {
             console.log(chalk.yellow('\nYou already submitted a standup today:\n'));
             console.log(chalk.bold('Yesterday:'), existing.yesterday);
             console.log(chalk.bold('Today:'), existing.today);
@@ -58,21 +59,16 @@ export async function standupCommand(options) {
         today = await promptField('What are you going to work on today?', true);
         blockers = await promptField('Any blockers? (leave empty if none)', false);
     }
-    const res = await authenticatedFetch('/standups', {
-        method: 'POST',
-        headers: { 'Content-Type': 'application/json' },
-        body: JSON.stringify({
+    try {
+        await client.standups.submit({
             yesterday,
             today,
             blockers: blockers || undefined,
-        }),
-    });
-    if (res.ok) {
+        });
         console.log(chalk.green('\n  ✓ Standup submitted!\n'));
     }
-    else {
-        const body = (await res.json());
-        console.error(chalk.red(`\nFailed to submit standup: ${body.error ?? res.statusText}`));
+    catch (error) {
+        console.error(chalk.red(`\nFailed to submit standup: ${error instanceof Error ? error.message : 'Unknown error'}`));
         process.exit(1);
     }
 }