@meltstudio/meltctl 4.38.0 → 4.39.0

package/dist/commands/version.test.js

@@ -1,86 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from 'vitest';
-vi.mock('../utils/version-check.js', () => ({
-    getCurrentCliVersion: vi.fn(),
-    getLatestCliVersion: vi.fn(),
-    compareVersions: vi.fn(),
-}));
-vi.mock('../utils/package-manager.js', () => ({
-    getUpdateInstructions: vi.fn(),
-}));
-import { getCurrentCliVersion, getLatestCliVersion, compareVersions, } from '../utils/version-check.js';
-import { getUpdateInstructions } from '../utils/package-manager.js';
-import { versionCheckCommand } from './version.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('versionCheckCommand', () => {
-    it('displays up-to-date message when versions match', async () => {
-        ;
-        getCurrentCliVersion.mockResolvedValue('4.26.0');
-        getLatestCliVersion.mockResolvedValue('4.26.0');
-        compareVersions.mockReturnValue(false);
-        await versionCheckCommand();
-        const logCalls = console.log.mock.calls.map((c) => c[0]);
-        expect(logCalls.some((msg) => typeof msg === 'string' && msg.includes('up to date'))).toBe(true);
-    });
-    it('displays update available when newer version exists', async () => {
-        ;
-        getCurrentCliVersion.mockResolvedValue('4.25.0');
-        getLatestCliVersion.mockResolvedValue('4.26.0');
-        compareVersions.mockReturnValue(true);
-        getUpdateInstructions.mockReturnValue([
-            'npm install -g @meltstudio/meltctl@latest',
-            '',
-            'Or with yarn:',
-            '  yarn global add @meltstudio/meltctl@latest',
-        ]);
-        await versionCheckCommand();
-        const logCalls = console.log.mock.calls.map((c) => c[0]);
-        expect(logCalls.some((msg) => typeof msg === 'string' && msg.includes('Update available'))).toBe(true);
-    });
-    it('shows update instructions when update is available', async () => {
-        ;
-        getCurrentCliVersion.mockResolvedValue('4.25.0');
-        getLatestCliVersion.mockResolvedValue('4.26.0');
-        compareVersions.mockReturnValue(true);
-        getUpdateInstructions.mockReturnValue(['npm install -g @meltstudio/meltctl@latest']);
-        await versionCheckCommand();
-        expect(getUpdateInstructions).toHaveBeenCalled();
-        const logCalls = console.log.mock.calls.map((c) => c[0]);
-        expect(logCalls.some((msg) => typeof msg === 'string' && msg.includes('To update, run'))).toBe(true);
-    });
-    it('shows warning when unable to check for updates (network error)', async () => {
-        ;
-        getCurrentCliVersion.mockResolvedValue('4.26.0');
-        getLatestCliVersion.mockResolvedValue(null);
-        await versionCheckCommand();
-        const logCalls = console.log.mock.calls.map((c) => c[0]);
-        expect(logCalls.some((msg) => typeof msg === 'string' && msg.includes('Unable to check for updates'))).toBe(true);
-    });
-    it('shows current version when network check fails', async () => {
-        ;
-        getCurrentCliVersion.mockResolvedValue('4.26.0');
-        getLatestCliVersion.mockResolvedValue(null);
-        await versionCheckCommand();
-        const logCalls = console.log.mock.calls.map((c) => c[0]);
-        expect(logCalls.some((msg) => typeof msg === 'string' && msg.includes('4.26.0'))).toBe(true);
-    });
-    it('exits with error when getCurrentCliVersion throws', async () => {
-        ;
-        getCurrentCliVersion.mockRejectedValue(new Error('Cannot read package.json'));
-        await expect(versionCheckCommand()).rejects.toThrow('process.exit(1)');
-        expect(console.error).toHaveBeenCalled();
-    });
-    it('exits with error when getLatestCliVersion throws', async () => {
-        ;
-        getCurrentCliVersion.mockResolvedValue('4.26.0');
-        getLatestCliVersion.mockRejectedValue(new Error('Unexpected error'));
-        await expect(versionCheckCommand()).rejects.toThrow('process.exit(1)');
-        expect(console.error).toHaveBeenCalled();
-    });
-});

package/dist/index.d.ts

@@ -1,2 +0,0 @@
-#!/usr/bin/env node
-export {};

package/dist/utils/analytics.d.ts

@@ -1 +0,0 @@
-export declare function trackCommand(command: string, success: boolean, errorMessage?: string): Promise<void>;

package/dist/utils/analytics.js

@@ -1,54 +0,0 @@
-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';
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = dirname(__filename);
-function getVersion() {
-    try {
-        const pkg = JSON.parse(readFileSync(join(__dirname, '../../package.json'), 'utf8'));
-        return pkg.version ?? 'unknown';
-    }
-    catch {
-        return 'unknown';
-    }
-}
-export async function trackCommand(command, success, errorMessage) {
-    try {
-        if (process.env['MELTCTL_NO_ANALYTICS']) {
-            debugLog('Analytics disabled via MELTCTL_NO_ANALYTICS');
-            return;
-        }
-        const auth = await getStoredAuth();
-        if (!auth || new Date(auth.expiresAt) <= new Date()) {
-            debugLog('Analytics skipped: not authenticated or token expired');
-            return;
-        }
-        const repo = getGitRepository();
-        const client = createMeltClient({ baseUrl: API_BASE, token: auth.token });
-        const controller = new AbortController();
-        const timeout = setTimeout(() => controller.abort(), 3000);
-        try {
-            await client.events.submit({
-                command,
-                project: getProjectName(),
-                repository: repo?.slug ?? null,
-                branch: getGitBranch(),
-                version: getVersion(),
-                success,
-                errorMessage: errorMessage?.slice(0, 500) ?? null,
-            });
-            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/analytics.test.d.ts

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

package/dist/utils/analytics.test.js

@@ -1,91 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from 'vitest';
-vi.mock('./auth.js', () => ({
-    getStoredAuth: vi.fn(),
-    API_BASE: 'https://api.test',
-}));
-vi.mock('./git.js', () => ({
-    getGitRepository: vi
-        .fn()
-        .mockReturnValue({ slug: 'org/repo', url: 'https://github.com/org/repo' }),
-    getGitBranch: vi.fn().mockReturnValue('main'),
-    getProjectName: vi.fn().mockReturnValue('test-project'),
-}));
-const mockFetch = vi.fn().mockResolvedValue({ ok: true });
-vi.stubGlobal('fetch', mockFetch);
-import { getStoredAuth } from './auth.js';
-import { trackCommand } from './analytics.js';
-beforeEach(() => {
-    vi.clearAllMocks();
-});
-describe('trackCommand', () => {
-    it('sends event when authenticated', async () => {
-        vi.mocked(getStoredAuth).mockResolvedValue({
-            token: 'test-token',
-            email: 'user@meltstudio.co',
-            expiresAt: new Date(Date.now() + 86400000).toISOString(),
-        });
-        await trackCommand('standup', true);
-        expect(mockFetch).toHaveBeenCalledWith('https://api.test/events', expect.objectContaining({
-            method: 'POST',
-            headers: expect.objectContaining({
-                Authorization: 'Bearer test-token',
-            }),
-        }));
-        const body = JSON.parse(mockFetch.mock.calls[0][1].body);
-        expect(body.command).toBe('standup');
-        expect(body.success).toBe(true);
-        expect(body.project).toBe('test-project');
-        expect(body.repository).toBe('org/repo');
-        expect(body.branch).toBe('main');
-    });
-    it('does not send event when not authenticated', async () => {
-        vi.mocked(getStoredAuth).mockResolvedValue(undefined);
-        await trackCommand('standup', true);
-        expect(mockFetch).not.toHaveBeenCalled();
-    });
-    it('does not send event when token is expired', async () => {
-        vi.mocked(getStoredAuth).mockResolvedValue({
-            token: 'test-token',
-            email: 'user@meltstudio.co',
-            expiresAt: new Date(Date.now() - 86400000).toISOString(),
-        });
-        await trackCommand('standup', true);
-        expect(mockFetch).not.toHaveBeenCalled();
-    });
-    it('does not throw when fetch fails', async () => {
-        vi.mocked(getStoredAuth).mockResolvedValue({
-            token: 'test-token',
-            email: 'user@meltstudio.co',
-            expiresAt: new Date(Date.now() + 86400000).toISOString(),
-        });
-        mockFetch.mockRejectedValueOnce(new Error('Network error'));
-        await expect(trackCommand('standup', true)).resolves.not.toThrow();
-    });
-    it('does not throw when auth check fails', async () => {
-        vi.mocked(getStoredAuth).mockRejectedValue(new Error('fs error'));
-        await expect(trackCommand('standup', true)).resolves.not.toThrow();
-    });
-    it('truncates error messages to 500 chars', async () => {
-        vi.mocked(getStoredAuth).mockResolvedValue({
-            token: 'test-token',
-            email: 'user@meltstudio.co',
-            expiresAt: new Date(Date.now() + 86400000).toISOString(),
-        });
-        const longError = 'x'.repeat(1000);
-        await trackCommand('standup', false, longError);
-        const body = JSON.parse(mockFetch.mock.calls[0][1].body);
-        expect(body.errorMessage.length).toBe(500);
-    });
-    it('includes success false and error message on failure', async () => {
-        vi.mocked(getStoredAuth).mockResolvedValue({
-            token: 'test-token',
-            email: 'user@meltstudio.co',
-            expiresAt: new Date(Date.now() + 86400000).toISOString(),
-        });
-        await trackCommand('audit submit', false, 'Not authenticated');
-        const body = JSON.parse(mockFetch.mock.calls[0][1].body);
-        expect(body.command).toBe('audit submit');
-        expect(body.success).toBe(false);
-        expect(body.errorMessage).toBe('Not authenticated');
-    });
-});

package/dist/utils/api.d.ts

@@ -1,3 +0,0 @@
-import { type MeltClient } from '@meltstudio/meltctl-sdk';
-export declare function getToken(): Promise<string>;
-export declare function getClient(): Promise<MeltClient>;

package/dist/utils/api.js

@@ -1,23 +0,0 @@
-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'];
-    if (envToken) {
-        return envToken;
-    }
-    const auth = await getStoredAuth();
-    if (!auth) {
-        console.error(chalk.red('Not authenticated. Run `npx @meltstudio/meltctl@latest login` or set MELTCTL_TOKEN for CI.'));
-        process.exit(1);
-    }
-    if (new Date(auth.expiresAt) <= new Date()) {
-        console.error(chalk.red('Session expired. Run `npx @meltstudio/meltctl@latest login` to re-authenticate, or set MELTCTL_TOKEN for CI.'));
-        process.exit(1);
-    }
-    return auth.token;
-}
-export async function getClient() {
-    const token = await getToken();
-    return createMeltClient({ baseUrl: API_BASE, token });
-}

package/dist/utils/api.test.d.ts

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

package/dist/utils/api.test.js

@@ -1,76 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from 'vitest';
-vi.mock('./auth.js', () => ({
-    getStoredAuth: vi.fn(),
-    API_BASE: 'https://test-api.example.com',
-}));
-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(() => { });
-    vi.spyOn(process, 'exit').mockImplementation((code) => {
-        throw new Error(`process.exit(${code})`);
-    });
-    delete process.env['MELTCTL_TOKEN'];
-});
-describe('getToken', () => {
-    it('returns env token when MELTCTL_TOKEN is set', async () => {
-        process.env['MELTCTL_TOKEN'] = 'env-token-123';
-        const token = await getToken();
-        expect(token).toBe('env-token-123');
-        expect(getStoredAuth).not.toHaveBeenCalled();
-    });
-    it('returns stored auth token when valid', async () => {
-        ;
-        getStoredAuth.mockResolvedValue({
-            token: 'stored-token',
-            email: 'dev@meltstudio.co',
-            expiresAt: '2099-12-31T00:00:00Z',
-        });
-        const token = await getToken();
-        expect(token).toBe('stored-token');
-    });
-    it('exits when no auth is available', async () => {
-        ;
-        getStoredAuth.mockResolvedValue(undefined);
-        await expect(getToken()).rejects.toThrow('process.exit(1)');
-        expect(console.error).toHaveBeenCalled();
-    });
-    it('exits when stored token is expired', async () => {
-        ;
-        getStoredAuth.mockResolvedValue({
-            token: 'expired-token',
-            email: 'dev@meltstudio.co',
-            expiresAt: '2020-01-01T00:00:00Z',
-        });
-        await expect(getToken()).rejects.toThrow('process.exit(1)');
-        expect(console.error).toHaveBeenCalled();
-    });
-});
-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',
-        });
-    });
-    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/auth.d.ts

@@ -1,12 +0,0 @@
-export declare const API_BASE: string;
-interface StoredAuth {
-    token: string;
-    email: string;
-    expiresAt: string;
-}
-export declare function getStoredAuth(): Promise<StoredAuth | undefined>;
-export declare function storeAuth(auth: StoredAuth): Promise<void>;
-export declare function clearAuth(): Promise<void>;
-export declare function isAuthenticated(): Promise<boolean>;
-export declare function authenticatedFetch(urlPath: string, options?: RequestInit): Promise<Response>;
-export {};

package/dist/utils/auth.js

@@ -1,54 +0,0 @@
-import fs from 'fs-extra';
-import path from 'path';
-import os from 'os';
-const AUTH_DIR = path.join(os.homedir(), '.meltctl');
-const AUTH_FILE = path.join(AUTH_DIR, 'auth.json');
-export const API_BASE = process.env['MELTCTL_API_URL'] ??
-    'https://ewszkw32he2ebgkwlbwmoubf5y0hllpx.lambda-url.us-east-1.on.aws';
-export async function getStoredAuth() {
-    if (!(await fs.pathExists(AUTH_FILE))) {
-        return undefined;
-    }
-    try {
-        return (await fs.readJson(AUTH_FILE));
-    }
-    catch {
-        return undefined;
-    }
-}
-export async function storeAuth(auth) {
-    await fs.ensureDir(AUTH_DIR);
-    await fs.writeJson(AUTH_FILE, auth, { spaces: 2 });
-}
-export async function clearAuth() {
-    if (await fs.pathExists(AUTH_FILE)) {
-        await fs.remove(AUTH_FILE);
-    }
-}
-export async function isAuthenticated() {
-    const auth = await getStoredAuth();
-    if (!auth) {
-        return false;
-    }
-    return new Date(auth.expiresAt) > new Date();
-}
-export async function authenticatedFetch(urlPath, options = {}) {
-    const auth = await getStoredAuth();
-    if (!auth) {
-        throw new Error('Not authenticated. Run `npx @meltstudio/meltctl@latest login` first.');
-    }
-    if (new Date(auth.expiresAt) <= new Date()) {
-        throw new Error('Session expired. Run `npx @meltstudio/meltctl@latest login` to re-authenticate.');
-    }
-    const response = await fetch(`${API_BASE}${urlPath}`, {
-        ...options,
-        headers: {
-            Authorization: `Bearer ${auth.token}`,
-            ...options.headers,
-        },
-    });
-    if (response.status === 401) {
-        throw new Error('Session expired. Run `npx @meltstudio/meltctl@latest login` to re-authenticate.');
-    }
-    return response;
-}

package/dist/utils/auth.test.d.ts

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

package/dist/utils/auth.test.js

@@ -1,165 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from 'vitest';
-vi.mock('fs-extra', () => ({
-    default: {
-        pathExists: vi.fn(),
-        readJson: vi.fn(),
-        ensureDir: vi.fn(),
-        writeJson: vi.fn(),
-        remove: vi.fn(),
-    },
-}));
-import fs from 'fs-extra';
-import { getStoredAuth, storeAuth, clearAuth, isAuthenticated, authenticatedFetch, API_BASE, } from './auth.js';
-beforeEach(() => {
-    vi.clearAllMocks();
-});
-describe('API_BASE', () => {
-    it('has a default value', () => {
-        expect(API_BASE).toBeTruthy();
-        expect(typeof API_BASE).toBe('string');
-    });
-});
-describe('getStoredAuth', () => {
-    it('returns undefined when auth file does not exist', async () => {
-        ;
-        fs.pathExists.mockResolvedValue(false);
-        const result = await getStoredAuth();
-        expect(result).toBeUndefined();
-    });
-    it('returns stored auth data when file exists', async () => {
-        const mockAuth = { token: 'abc', email: 'dev@meltstudio.co', expiresAt: '2026-12-31' };
-        fs.pathExists.mockResolvedValue(true);
-        fs.readJson.mockResolvedValue(mockAuth);
-        const result = await getStoredAuth();
-        expect(result).toEqual(mockAuth);
-    });
-    it('returns undefined when readJson throws', async () => {
-        ;
-        fs.pathExists.mockResolvedValue(true);
-        fs.readJson.mockRejectedValue(new Error('parse error'));
-        const result = await getStoredAuth();
-        expect(result).toBeUndefined();
-    });
-});
-describe('storeAuth', () => {
-    it('creates directory and writes auth file', async () => {
-        const auth = { token: 'tok', email: 'a@meltstudio.co', expiresAt: '2026-12-31' };
-        await storeAuth(auth);
-        expect(fs.ensureDir).toHaveBeenCalled();
-        expect(fs.writeJson).toHaveBeenCalledWith(expect.stringContaining('auth.json'), auth, {
-            spaces: 2,
-        });
-    });
-});
-describe('clearAuth', () => {
-    it('removes auth file when it exists', async () => {
-        ;
-        fs.pathExists.mockResolvedValue(true);
-        await clearAuth();
-        expect(fs.remove).toHaveBeenCalled();
-    });
-    it('does nothing when auth file does not exist', async () => {
-        ;
-        fs.pathExists.mockResolvedValue(false);
-        await clearAuth();
-        expect(fs.remove).not.toHaveBeenCalled();
-    });
-});
-describe('isAuthenticated', () => {
-    it('returns false when no stored auth', async () => {
-        ;
-        fs.pathExists.mockResolvedValue(false);
-        expect(await isAuthenticated()).toBe(false);
-    });
-    it('returns false when token is expired', async () => {
-        ;
-        fs.pathExists.mockResolvedValue(true);
-        fs.readJson.mockResolvedValue({
-            token: 'tok',
-            email: 'a@meltstudio.co',
-            expiresAt: '2020-01-01T00:00:00Z',
-        });
-        expect(await isAuthenticated()).toBe(false);
-    });
-    it('returns true when token is valid and not expired', async () => {
-        ;
-        fs.pathExists.mockResolvedValue(true);
-        fs.readJson.mockResolvedValue({
-            token: 'tok',
-            email: 'a@meltstudio.co',
-            expiresAt: '2099-12-31T00:00:00Z',
-        });
-        expect(await isAuthenticated()).toBe(true);
-    });
-});
-describe('authenticatedFetch', () => {
-    it('throws when not authenticated', async () => {
-        ;
-        fs.pathExists.mockResolvedValue(false);
-        await expect(authenticatedFetch('/test')).rejects.toThrow('Not authenticated');
-    });
-    it('throws when session expired', async () => {
-        ;
-        fs.pathExists.mockResolvedValue(true);
-        fs.readJson.mockResolvedValue({
-            token: 'tok',
-            email: 'a@meltstudio.co',
-            expiresAt: '2020-01-01T00:00:00Z',
-        });
-        await expect(authenticatedFetch('/test')).rejects.toThrow('expired');
-    });
-    it('makes authenticated request with bearer token', async () => {
-        ;
-        fs.pathExists.mockResolvedValue(true);
-        fs.readJson.mockResolvedValue({
-            token: 'my-jwt',
-            email: 'a@meltstudio.co',
-            expiresAt: '2099-12-31T00:00:00Z',
-        });
-        const mockResponse = { status: 200, ok: true };
-        const fetchMock = vi.fn().mockResolvedValue(mockResponse);
-        vi.stubGlobal('fetch', fetchMock);
-        const result = await authenticatedFetch('/templates');
-        expect(result).toBe(mockResponse);
-        expect(fetchMock).toHaveBeenCalledWith(`${API_BASE}/templates`, expect.objectContaining({
-            headers: expect.objectContaining({
-                Authorization: 'Bearer my-jwt',
-            }),
-        }));
-        vi.unstubAllGlobals();
-    });
-    it('throws when API returns 401', async () => {
-        ;
-        fs.pathExists.mockResolvedValue(true);
-        fs.readJson.mockResolvedValue({
-            token: 'expired-jwt',
-            email: 'a@meltstudio.co',
-            expiresAt: '2099-12-31T00:00:00Z',
-        });
-        const fetchMock = vi.fn().mockResolvedValue({ status: 401, ok: false });
-        vi.stubGlobal('fetch', fetchMock);
-        await expect(authenticatedFetch('/test')).rejects.toThrow('expired');
-        vi.unstubAllGlobals();
-    });
-    it('merges custom headers with auth header', async () => {
-        ;
-        fs.pathExists.mockResolvedValue(true);
-        fs.readJson.mockResolvedValue({
-            token: 'jwt',
-            email: 'a@meltstudio.co',
-            expiresAt: '2099-12-31T00:00:00Z',
-        });
-        const fetchMock = vi.fn().mockResolvedValue({ status: 200, ok: true });
-        vi.stubGlobal('fetch', fetchMock);
-        await authenticatedFetch('/test', {
-            headers: { 'Content-Type': 'application/json' },
-        });
-        expect(fetchMock).toHaveBeenCalledWith(expect.any(String), expect.objectContaining({
-            headers: expect.objectContaining({
-                Authorization: 'Bearer jwt',
-                'Content-Type': 'application/json',
-            }),
-        }));
-        vi.unstubAllGlobals();
-    });
-});

package/dist/utils/banner.d.ts

@@ -1 +0,0 @@
-export declare function printBanner(): void;

package/dist/utils/banner.js

@@ -1,22 +0,0 @@
-import chalk from 'chalk';
-import gradient from 'gradient-string';
-import { readFileSync } from 'fs';
-import { join, dirname } from 'path';
-import { fileURLToPath } from 'url';
-const __dirname = dirname(fileURLToPath(import.meta.url));
-const pkg = JSON.parse(readFileSync(join(__dirname, '../../package.json'), 'utf8'));
-// Melt brand colors: yellow, magenta/pink, cyan, red, orange
-const meltGradient = gradient(['#FFC107', '#E91E63', '#00BCD4', '#FF5722']);
-const LOGO = `
-  ███╗   ███╗███████╗██╗  ████████╗ ██████╗████████╗██╗
-  ████╗ ████║██╔════╝██║  ╚══██╔══╝██╔════╝╚══██╔══╝██║
-  ██╔████╔██║█████╗  ██║     ██║   ██║        ██║   ██║
-  ██║╚██╔╝██║██╔══╝  ██║     ██║   ██║        ██║   ██║
-  ██║ ╚═╝ ██║███████╗███████╗██║   ╚██████╗   ██║   ███████╗
-  ╚═╝     ╚═╝╚══════╝╚══════╝╚═╝    ╚═════╝   ╚═╝   ╚══════╝`;
-export function printBanner() {
-    console.log(meltGradient(LOGO));
-    console.log();
-    console.log(`  ${chalk.dim('v' + pkg.version)}  ${chalk.dim('·')}  ${chalk.dim('AI-first development tools for teams')}`);
-    console.log();
-}

package/dist/utils/banner.test.d.ts

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

package/dist/utils/banner.test.js

@@ -1,34 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from 'vitest';
-vi.mock('fs', () => ({
-    readFileSync: vi.fn().mockReturnValue(JSON.stringify({ version: '1.2.3' })),
-}));
-vi.mock('gradient-string', () => ({
-    default: vi.fn().mockReturnValue(vi.fn((str) => str)),
-}));
-import { printBanner } from './banner.js';
-beforeEach(() => {
-    vi.clearAllMocks();
-    vi.spyOn(console, 'log').mockImplementation(() => { });
-});
-describe('printBanner', () => {
-    it('does not throw', () => {
-        expect(() => printBanner()).not.toThrow();
-    });
-    it('calls console.log at least once', () => {
-        printBanner();
-        expect(console.log).toHaveBeenCalled();
-    });
-    it('prints output containing MELTCTL logo text', () => {
-        printBanner();
-        const logCalls = console.log.mock.calls.map((c) => c[0]);
-        const allOutput = logCalls.filter(Boolean).join('\n');
-        // The logo contains block characters for MELTCTL
-        expect(allOutput).toContain('███');
-    });
-    it('prints version info', () => {
-        printBanner();
-        const logCalls = console.log.mock.calls.map((c) => String(c[0] ?? ''));
-        const hasVersion = logCalls.some((msg) => msg.includes('v1.2.3') || msg.includes('1.2.3'));
-        expect(hasVersion).toBe(true);
-    });
-});

package/dist/utils/debug.d.ts

@@ -1 +0,0 @@
-export declare function debugLog(message: string): void;

package/dist/utils/debug.js

@@ -1,6 +0,0 @@
-import chalk from 'chalk';
-export function debugLog(message) {
-    if (process.env['MELTCTL_DEBUG']) {
-        console.error(chalk.dim(`[debug] ${message}`));
-    }
-}