@meltstudio/meltctl 4.38.0 → 4.39.0

package/dist/commands/login.test.js

@@ -1,194 +0,0 @@
-import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
-vi.mock('../utils/auth.js', () => ({
-    API_BASE: 'https://test-api.example.com',
-    storeAuth: vi.fn(),
-}));
-vi.mock('../utils/banner.js', () => ({
-    printBanner: vi.fn(),
-}));
-vi.mock('child_process', () => ({
-    exec: vi.fn(),
-}));
-// We need to mock http.createServer to control the server behavior
-// Store the request handler so we can invoke it manually
-let capturedRequestHandler = null;
-const mockServer = {
-    listen: vi.fn((_port, cb) => {
-        if (cb)
-            cb();
-        return mockServer;
-    }),
-    close: vi.fn((cb) => {
-        if (cb)
-            cb();
-        return mockServer;
-    }),
-    address: vi.fn(() => ({ port: 12345 })),
-};
-vi.mock('http', () => ({
-    default: {
-        createServer: vi.fn((handler) => {
-            // First call is from findFreePort - returns a server that finds a free port
-            // Second call is the actual OAuth server
-            if (!capturedRequestHandler && handler) {
-                capturedRequestHandler = handler;
-            }
-            return mockServer;
-        }),
-    },
-    createServer: vi.fn((handler) => {
-        if (!capturedRequestHandler && handler) {
-            capturedRequestHandler = handler;
-        }
-        return mockServer;
-    }),
-}));
-import { storeAuth, API_BASE } from '../utils/auth.js';
-import { loginCommand } from './login.js';
-function createMockReq(urlPath) {
-    return { url: urlPath };
-}
-function createMockRes() {
-    const res = {
-        _body: '',
-        _statusCode: 200,
-        writeHead: vi.fn(function (code) {
-            this._statusCode = code;
-            return res;
-        }),
-        end: vi.fn(function (body) {
-            this._body = body ?? '';
-            return res;
-        }),
-    };
-    return res;
-}
-beforeEach(() => {
-    vi.clearAllMocks();
-    capturedRequestHandler = null;
-    vi.spyOn(console, 'log').mockImplementation(() => { });
-    vi.spyOn(console, 'error').mockImplementation(() => { });
-    vi.spyOn(process, 'exit').mockImplementation((code) => {
-        throw new Error(`process.exit(${code})`);
-    });
-});
-afterEach(() => {
-    vi.unstubAllGlobals();
-});
-describe('loginCommand', () => {
-    it('handles successful OAuth callback and stores auth', async () => {
-        const mockTokenResponse = {
-            token: 'jwt-token-123',
-            email: 'dev@meltstudio.co',
-            expiresAt: '2026-04-02T00:00:00Z',
-        };
-        const fetchMock = vi.fn().mockResolvedValue({
-            ok: true,
-            json: vi.fn().mockResolvedValue(mockTokenResponse),
-        });
-        vi.stubGlobal('fetch', fetchMock);
-        // Start loginCommand - it will call findFreePort then createServer
-        const loginPromise = loginCommand();
-        // Allow microtasks to settle so createServer and listen are called
-        await new Promise(r => setTimeout(r, 10));
-        // Simulate the OAuth callback with a valid code
-        expect(capturedRequestHandler).not.toBeNull();
-        const req = createMockReq('/?code=auth-code-xyz');
-        const res = createMockRes();
-        capturedRequestHandler(req, res);
-        await loginPromise;
-        expect(fetchMock).toHaveBeenCalledWith(`${API_BASE}/auth/token`, expect.objectContaining({
-            method: 'POST',
-            body: expect.stringContaining('auth-code-xyz'),
-        }));
-        expect(storeAuth).toHaveBeenCalledWith({
-            token: 'jwt-token-123',
-            email: 'dev@meltstudio.co',
-            expiresAt: '2026-04-02T00:00:00Z',
-        });
-        expect(res._statusCode).toBe(200);
-        expect(res._body).toContain('successful');
-    });
-    it('exits with error when token exchange returns 403', async () => {
-        const fetchMock = vi.fn().mockResolvedValue({
-            ok: false,
-            status: 403,
-            json: vi.fn().mockResolvedValue({ error: 'Forbidden' }),
-        });
-        vi.stubGlobal('fetch', fetchMock);
-        const loginPromise = loginCommand();
-        await new Promise(r => setTimeout(r, 10));
-        const req = createMockReq('/?code=test-code');
-        const res = createMockRes();
-        capturedRequestHandler(req, res);
-        await expect(loginPromise).rejects.toThrow('process.exit(1)');
-        const errorCalls = console.error.mock.calls.map((c) => String(c[0]));
-        expect(errorCalls.some((msg) => msg.includes('meltstudio.co'))).toBe(true);
-    });
-    it('exits with error when token exchange returns generic failure', async () => {
-        const fetchMock = vi.fn().mockResolvedValue({
-            ok: false,
-            status: 500,
-            json: vi.fn().mockResolvedValue({ error: 'Server error' }),
-        });
-        vi.stubGlobal('fetch', fetchMock);
-        const loginPromise = loginCommand();
-        await new Promise(r => setTimeout(r, 10));
-        const req = createMockReq('/?code=test-code');
-        const res = createMockRes();
-        capturedRequestHandler(req, res);
-        await expect(loginPromise).rejects.toThrow('process.exit(1)');
-        const errorCalls = console.error.mock.calls.map((c) => String(c[0]));
-        expect(errorCalls.some((msg) => msg.includes('Server error'))).toBe(true);
-    });
-    it('rejects when OAuth callback returns error param', async () => {
-        const loginPromise = loginCommand();
-        await new Promise(r => setTimeout(r, 10));
-        const req = createMockReq('/?error=access_denied');
-        const res = createMockRes();
-        capturedRequestHandler(req, res);
-        await expect(loginPromise).rejects.toThrow('Authentication denied: access_denied');
-        expect(res._statusCode).toBe(200);
-        expect(res._body).toContain('failed');
-    });
-    it('handles token response with missing fields gracefully', async () => {
-        // Token response missing expiresAt
-        const fetchMock = vi.fn().mockResolvedValue({
-            ok: true,
-            json: vi.fn().mockResolvedValue({ token: 'jwt-token', email: 'dev@meltstudio.co' }),
-        });
-        vi.stubGlobal('fetch', fetchMock);
-        const loginPromise = loginCommand();
-        await new Promise(r => setTimeout(r, 10));
-        const req = createMockReq('/?code=test-code');
-        const res = createMockRes();
-        capturedRequestHandler(req, res);
-        await loginPromise;
-        // storeAuth is called with undefined for expiresAt since the field is missing
-        expect(storeAuth).toHaveBeenCalledWith({
-            token: 'jwt-token',
-            email: 'dev@meltstudio.co',
-            expiresAt: undefined,
-        });
-    });
-    it('returns 400 when callback has no code or error', async () => {
-        const fetchMock = vi.fn().mockResolvedValue({
-            ok: true,
-            json: vi.fn().mockResolvedValue({ token: 't', email: 'e@meltstudio.co', expiresAt: 'x' }),
-        });
-        vi.stubGlobal('fetch', fetchMock);
-        const loginPromise = loginCommand();
-        await new Promise(r => setTimeout(r, 10));
-        // Send request with no params
-        const req1 = createMockReq('/');
-        const res1 = createMockRes();
-        capturedRequestHandler(req1, res1);
-        expect(res1._statusCode).toBe(400);
-        expect(res1._body).toContain('Missing authorization code');
-        // Send valid code to complete
-        const req2 = createMockReq('/?code=valid');
-        const res2 = createMockRes();
-        capturedRequestHandler(req2, res2);
-        await loginPromise;
-    });
-});

package/dist/commands/logout.d.ts

@@ -1 +0,0 @@
-export declare function logoutCommand(): Promise<void>;

package/dist/commands/logout.js

@@ -1,12 +0,0 @@
-import chalk from 'chalk';
-import { clearAuth, getStoredAuth } from '../utils/auth.js';
-export async function logoutCommand() {
-    const auth = await getStoredAuth();
-    await clearAuth();
-    if (auth) {
-        console.log(chalk.green(`Logged out (was ${auth.email})`));
-    }
-    else {
-        console.log(chalk.dim('No active session found.'));
-    }
-}

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

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

package/dist/commands/logout.test.js

@@ -1,59 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from 'vitest';
-vi.mock('../utils/auth.js', () => ({
-    getStoredAuth: vi.fn(),
-    clearAuth: vi.fn(),
-}));
-import { getStoredAuth, clearAuth } from '../utils/auth.js';
-import { logoutCommand } from './logout.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('logoutCommand', () => {
-    it('clears auth and shows logged-out message with email when session exists', async () => {
-        ;
-        getStoredAuth.mockResolvedValue({
-            token: 'jwt-token',
-            email: 'dev@meltstudio.co',
-            expiresAt: '2026-04-01T00:00:00Z',
-        });
-        clearAuth.mockResolvedValue(undefined);
-        await logoutCommand();
-        expect(clearAuth).toHaveBeenCalled();
-        const logCalls = console.log.mock.calls.map((c) => c[0]);
-        expect(logCalls.some((msg) => typeof msg === 'string' && msg.includes('Logged out'))).toBe(true);
-        expect(logCalls.some((msg) => typeof msg === 'string' && msg.includes('dev@meltstudio.co'))).toBe(true);
-    });
-    it('clears auth and shows "no active session" when no session exists', async () => {
-        ;
-        getStoredAuth.mockResolvedValue(undefined);
-        clearAuth.mockResolvedValue(undefined);
-        await logoutCommand();
-        expect(clearAuth).toHaveBeenCalled();
-        const logCalls = console.log.mock.calls.map((c) => c[0]);
-        expect(logCalls.some((msg) => typeof msg === 'string' && msg.includes('No active session'))).toBe(true);
-    });
-    it('always calls clearAuth regardless of session state', async () => {
-        ;
-        getStoredAuth.mockResolvedValue(undefined);
-        clearAuth.mockResolvedValue(undefined);
-        await logoutCommand();
-        expect(clearAuth).toHaveBeenCalledTimes(1);
-    });
-    it('calls getStoredAuth before clearAuth', async () => {
-        const callOrder = [];
-        getStoredAuth.mockImplementation(async () => {
-            callOrder.push('getStoredAuth');
-            return { token: 'tok', email: 'a@b.co', expiresAt: '2026-04-01T00:00:00Z' };
-        });
-        clearAuth.mockImplementation(async () => {
-            callOrder.push('clearAuth');
-        });
-        await logoutCommand();
-        expect(callOrder).toEqual(['getStoredAuth', 'clearAuth']);
-    });
-});

package/dist/commands/plan.d.ts

@@ -1,6 +0,0 @@
-export declare function planSubmitCommand(file?: string): Promise<void>;
-export declare function planListCommand(options: {
-    repository?: string;
-    author?: string;
-    limit?: string;
-}): Promise<void>;

package/dist/commands/plan.js

@@ -1,123 +0,0 @@
-import chalk from 'chalk';
-import fs from 'fs-extra';
-import path from 'path';
-import { getClient } from '../utils/api.js';
-import { getGitBranch, getGitCommit, getGitRepository, getProjectName, extractTicketId, findMdFiles, } from '../utils/git.js';
-function extractFrontmatterStatus(content) {
-    const match = content.match(/^---\n([\s\S]*?)\n---/);
-    if (!match)
-        return null;
-    const statusMatch = match[1].match(/^status:\s*(.+)$/m);
-    return statusMatch ? statusMatch[1].trim() : null;
-}
-async function autoDetectPlanFile() {
-    const cwd = process.cwd();
-    const plansDir = path.join(cwd, '.plans');
-    const mdFiles = await findMdFiles(plansDir);
-    if (mdFiles.length === 0) {
-        return null;
-    }
-    const branch = getGitBranch();
-    const ticketId = extractTicketId(branch);
-    if (ticketId) {
-        const ticketLower = ticketId.toLowerCase();
-        const match = mdFiles.find(f => path.basename(f).toLowerCase().includes(ticketLower));
-        if (match) {
-            return match;
-        }
-    }
-    return mdFiles[0] ?? null;
-}
-export async function planSubmitCommand(file) {
-    const client = await getClient();
-    let filePath;
-    if (file) {
-        filePath = path.resolve(file);
-    }
-    else {
-        const detected = await autoDetectPlanFile();
-        if (!detected) {
-            console.error(chalk.red('No plan file found. Provide a file path or create a plan in the .plans/ directory.'));
-            process.exit(1);
-        }
-        filePath = detected;
-        console.log(chalk.dim(`Auto-detected plan file: ${path.relative(process.cwd(), filePath)}`));
-    }
-    if (!(await fs.pathExists(filePath))) {
-        console.error(chalk.red(`File not found: ${filePath}`));
-        process.exit(1);
-    }
-    const content = await fs.readFile(filePath, 'utf-8');
-    const filename = path.basename(filePath);
-    const project = getProjectName();
-    const branch = getGitBranch();
-    const commit = getGitCommit();
-    const repo = getGitRepository();
-    const ticket = extractTicketId(branch) ?? extractTicketId(filename);
-    const status = extractFrontmatterStatus(content);
-    try {
-        const result = await client.plans.submit({
-            project,
-            repository: repo?.slug ?? null,
-            repositoryUrl: repo?.url ?? null,
-            branch,
-            commit,
-            content,
-            ticket: ticket ?? null,
-            status: status ?? null,
-            metadata: { filename },
-        });
-        if (result.created) {
-            console.log(chalk.green(`\n  ✓ Plan submitted! ID: ${result.id}\n`));
-        }
-        else {
-            console.log(chalk.green(`\n  ✓ Plan updated! ID: ${result.id}\n`));
-        }
-    }
-    catch (error) {
-        console.error(chalk.red(`Failed to submit plan: ${error instanceof Error ? error.message : 'Unknown error'}`));
-        process.exit(1);
-    }
-}
-export async function planListCommand(options) {
-    const client = await getClient();
-    try {
-        const body = await client.plans.list({
-            repository: options.repository,
-            author: options.author,
-            limit: options.limit ? parseInt(options.limit, 10) : undefined,
-        });
-        if (body.plans.length === 0) {
-            console.log(chalk.dim('\n  No plans found.\n'));
-            return;
-        }
-        console.log(chalk.bold(`\n  Plans (${body.count}):\n`));
-        console.log(chalk.dim(`  ${'TICKET'.padEnd(14)} ${'STATUS'.padEnd(12)} ${'REPOSITORY'.padEnd(36)} ${'AUTHOR'.padEnd(30)} UPDATED`));
-        console.log();
-        const statusColors = {
-            submitted: chalk.dim,
-            approved: chalk.cyan,
-            validated: chalk.green,
-            reviewed: chalk.magenta,
-        };
-        for (const p of body.plans) {
-            const date = new Date(p.updatedAt).toLocaleDateString('en-US', {
-                month: 'short',
-                day: 'numeric',
-                year: 'numeric',
-                hour: '2-digit',
-                minute: '2-digit',
-            });
-            const repo = p.repository ?? p.project;
-            const ticket = p.ticket ?? '-';
-            const colorFn = statusColors[p.status] ?? chalk.dim;
-            console.log(`  ${chalk.white(ticket.padEnd(14))} ${colorFn(p.status.padEnd(12))} ${chalk.white(repo.padEnd(36))} ${chalk.dim(p.author.padEnd(30))} ${chalk.dim(date)}`);
-        }
-        console.log();
-    }
-    catch (error) {
-        const msg = error instanceof Error ? error.message : 'Unknown error';
-        console.error(chalk.red(`Failed to list plans: ${msg}`));
-        process.exit(1);
-    }
-}

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

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

package/dist/commands/plan.test.js

@@ -1,246 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from 'vitest';
-vi.mock('fs-extra', () => ({
-    default: {
-        pathExists: vi.fn(),
-        readFile: vi.fn(),
-    },
-}));
-const mockClient = vi.hoisted(() => ({
-    plans: {
-        submit: vi.fn(),
-        list: vi.fn(),
-    },
-}));
-vi.mock('../utils/api.js', () => ({
-    getClient: vi.fn().mockResolvedValue(mockClient),
-}));
-vi.mock('../utils/git.js', () => ({
-    getGitBranch: vi.fn(),
-    getGitCommit: vi.fn(),
-    getGitRepository: vi.fn(),
-    getProjectName: vi.fn(),
-    extractTicketId: vi.fn(),
-    findMdFiles: vi.fn(),
-}));
-import fs from 'fs-extra';
-import { getGitBranch, getGitCommit, getGitRepository, getProjectName, extractTicketId, findMdFiles, } from '../utils/git.js';
-import { planSubmitCommand, planListCommand } from './plan.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('planSubmitCommand', () => {
-    function setupGitMocks() {
-        ;
-        getGitBranch.mockReturnValue('feature/PROJ-123-add-feature');
-        getGitCommit.mockReturnValue('def5678');
-        getGitRepository.mockReturnValue({
-            slug: 'Org/Repo',
-            url: 'https://github.com/Org/Repo.git',
-        });
-        getProjectName.mockReturnValue('test-project');
-        extractTicketId.mockReturnValue('PROJ-123');
-    }
-    it('submits a plan with correct payload fields', async () => {
-        setupGitMocks();
-        fs.pathExists.mockResolvedValue(true);
-        fs.readFile.mockResolvedValue('# Plan\nSome plan content.');
-        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');
-        expect(mockClient.plans.submit).toHaveBeenCalledWith({
-            project: 'test-project',
-            repository: 'Org/Repo',
-            repositoryUrl: 'https://github.com/Org/Repo.git',
-            branch: 'feature/PROJ-123-add-feature',
-            commit: 'def5678',
-            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');
-        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);
-    });
-    it('logs "Plan updated" when API returns created: false', async () => {
-        setupGitMocks();
-        fs.pathExists.mockResolvedValue(true);
-        fs.readFile.mockResolvedValue('updated plan content');
-        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);
-    });
-    it('exits with error when file not found', async () => {
-        setupGitMocks();
-        fs.pathExists.mockResolvedValue(false);
-        await expect(planSubmitCommand('nonexistent.md')).rejects.toThrow('process.exit(1)');
-        expect(console.error).toHaveBeenCalled();
-    });
-    it('exits with error when API returns failure', async () => {
-        setupGitMocks();
-        fs.pathExists.mockResolvedValue(true);
-        fs.readFile.mockResolvedValue('content');
-        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 () => {
-        setupGitMocks();
-        findMdFiles.mockResolvedValue(['/project/.plans/PROJ-123-plan.md']);
-        extractTicketId.mockReturnValue('PROJ-123');
-        fs.pathExists.mockResolvedValue(true);
-        fs.readFile.mockResolvedValue('auto-detected plan');
-        mockClient.plans.submit.mockResolvedValue({
-            id: 'plan-auto',
-            createdAt: '2026-03-26T00:00:00Z',
-            updatedAt: '2026-03-26T00:00:00Z',
-            created: true,
-        });
-        await planSubmitCommand();
-        expect(mockClient.plans.submit).toHaveBeenCalledWith(expect.objectContaining({
-            content: 'auto-detected plan',
-        }));
-    });
-    it('exits with error when no file provided and none auto-detected', async () => {
-        ;
-        findMdFiles.mockResolvedValue([]);
-        getGitBranch.mockReturnValue('main');
-        extractTicketId.mockReturnValue(null);
-        await expect(planSubmitCommand()).rejects.toThrow('process.exit(1)');
-        expect(console.error).toHaveBeenCalled();
-    });
-    it('does not include ticket in payload when extractTicketId returns null', async () => {
-        ;
-        getGitBranch.mockReturnValue('main');
-        getGitCommit.mockReturnValue('abc1234');
-        getGitRepository.mockReturnValue({
-            slug: 'Org/Repo',
-            url: 'https://github.com/Org/Repo.git',
-        });
-        getProjectName.mockReturnValue('test-project');
-        extractTicketId.mockReturnValue(null);
-        fs.pathExists.mockResolvedValue(true);
-        fs.readFile.mockResolvedValue('plan without ticket');
-        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');
-        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');
-        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');
-        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.');
-        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');
-        expect(mockClient.plans.submit).toHaveBeenCalledWith(expect.objectContaining({
-            status: null,
-        }));
-    });
-});
-describe('planListCommand', () => {
-    it('calls API with correct query params', async () => {
-        mockClient.plans.list.mockResolvedValue({ plans: [], count: 0 });
-        await planListCommand({ repository: 'Org/Repo', author: 'dev@meltstudio.co', limit: '5' });
-        expect(mockClient.plans.list).toHaveBeenCalledWith({
-            repository: 'Org/Repo',
-            author: 'dev@meltstudio.co',
-            limit: 5,
-        });
-    });
-    it('exits with error on 403 response', async () => {
-        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 () => {
-        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 () => {
-        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 () => {
-        mockClient.plans.list.mockResolvedValue({ plans: [], count: 0 });
-        await planListCommand({});
-        expect(mockClient.plans.list).toHaveBeenCalledWith({
-            repository: undefined,
-            author: undefined,
-            limit: undefined,
-        });
-    });
-    it('exits with error on non-403 failure response', async () => {
-        mockClient.plans.list.mockRejectedValue(new Error('Server error'));
-        await expect(planListCommand({})).rejects.toThrow('process.exit(1)');
-    });
-});

package/dist/commands/standup.d.ts

@@ -1,7 +0,0 @@
-interface StandupOptions {
-    yesterday?: string;
-    today?: string;
-    blockers?: string;
-}
-export declare function standupCommand(options: StandupOptions): Promise<void>;
-export {};