@meltstudio/meltctl 4.38.0 → 4.39.0

package/dist/utils/git.d.ts

@@ -1,9 +0,0 @@
-export declare function getGitBranch(): string;
-export declare function getGitCommit(): string;
-export declare function getGitRepository(): {
-    slug: string;
-    url: string;
-} | null;
-export declare function getProjectName(): string;
-export declare function extractTicketId(branch: string): string | null;
-export declare function findMdFiles(dir: string): Promise<string[]>;

package/dist/utils/git.js

@@ -1,76 +0,0 @@
-import fs from 'fs-extra';
-import path from 'path';
-import { execSync } from 'child_process';
-export function getGitBranch() {
-    try {
-        return execSync('git rev-parse --abbrev-ref HEAD', { encoding: 'utf-8' }).trim();
-    }
-    catch {
-        return 'unknown';
-    }
-}
-export function getGitCommit() {
-    try {
-        return execSync('git rev-parse --short HEAD', { encoding: 'utf-8' }).trim();
-    }
-    catch {
-        return 'unknown';
-    }
-}
-export function getGitRepository() {
-    try {
-        const url = execSync('git remote get-url origin', { encoding: 'utf-8' }).trim();
-        // Extract owner/repo from various URL formats:
-        // git@github.com:Owner/Repo.git -> Owner/Repo
-        // https://github.com/Owner/Repo.git -> Owner/Repo
-        // git@gitlab.com:Owner/Repo.git -> Owner/Repo
-        const match = url.match(/[/:]([\w.-]+\/[\w.-]+?)(?:\.git)?$/);
-        const slug = match ? match[1] : url;
-        return { slug, url };
-    }
-    catch {
-        return null;
-    }
-}
-export function getProjectName() {
-    const cwd = process.cwd();
-    try {
-        const pkgPath = path.join(cwd, 'package.json');
-        if (fs.pathExistsSync(pkgPath)) {
-            const pkg = fs.readJsonSync(pkgPath);
-            if (pkg.name) {
-                return pkg.name;
-            }
-        }
-    }
-    catch {
-        // fall through
-    }
-    return path.basename(cwd);
-}
-export function extractTicketId(branch) {
-    const match = branch.match(/([A-Z]+-\d+)/i);
-    return match ? match[1] : null;
-}
-export async function findMdFiles(dir) {
-    if (!(await fs.pathExists(dir))) {
-        return [];
-    }
-    const results = [];
-    async function walk(current) {
-        const entries = await fs.readdir(current, { withFileTypes: true });
-        for (const entry of entries) {
-            const fullPath = path.join(current, entry.name);
-            if (entry.isDirectory()) {
-                await walk(fullPath);
-            }
-            else if (entry.isFile() && entry.name.endsWith('.md')) {
-                const stat = await fs.stat(fullPath);
-                results.push({ path: fullPath, mtime: stat.mtimeMs });
-            }
-        }
-    }
-    await walk(dir);
-    results.sort((a, b) => b.mtime - a.mtime);
-    return results.map(r => r.path);
-}

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

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

package/dist/utils/git.test.js

@@ -1,184 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from 'vitest';
-vi.mock('child_process', () => ({
-    execSync: vi.fn(),
-}));
-vi.mock('fs-extra', () => ({
-    default: {
-        pathExistsSync: vi.fn(),
-        readJsonSync: vi.fn(),
-        pathExists: vi.fn(),
-        readdir: vi.fn(),
-        stat: vi.fn(),
-    },
-}));
-import { execSync } from 'child_process';
-import fs from 'fs-extra';
-import { getGitBranch, getGitCommit, getGitRepository, getProjectName, extractTicketId, findMdFiles, } from './git.js';
-beforeEach(() => {
-    vi.clearAllMocks();
-});
-describe('getGitBranch', () => {
-    it('returns trimmed branch name', () => {
-        ;
-        execSync.mockReturnValue('  feature/my-branch\n');
-        expect(getGitBranch()).toBe('feature/my-branch');
-    });
-    it('returns "unknown" when git command fails', () => {
-        ;
-        execSync.mockImplementation(() => {
-            throw new Error('not a git repo');
-        });
-        expect(getGitBranch()).toBe('unknown');
-    });
-});
-describe('getGitCommit', () => {
-    it('returns trimmed commit hash', () => {
-        ;
-        execSync.mockReturnValue('abc1234\n');
-        expect(getGitCommit()).toBe('abc1234');
-    });
-    it('returns "unknown" when git command fails', () => {
-        ;
-        execSync.mockImplementation(() => {
-            throw new Error('not a git repo');
-        });
-        expect(getGitCommit()).toBe('unknown');
-    });
-});
-describe('getGitRepository', () => {
-    it('parses SSH URL format', () => {
-        ;
-        execSync.mockReturnValue('git@github.com:Owner/Repo.git\n');
-        const result = getGitRepository();
-        expect(result).toEqual({
-            slug: 'Owner/Repo',
-            url: 'git@github.com:Owner/Repo.git',
-        });
-    });
-    it('parses HTTPS URL format', () => {
-        ;
-        execSync.mockReturnValue('https://github.com/Owner/Repo.git\n');
-        const result = getGitRepository();
-        expect(result).toEqual({
-            slug: 'Owner/Repo',
-            url: 'https://github.com/Owner/Repo.git',
-        });
-    });
-    it('parses HTTPS URL without .git suffix', () => {
-        ;
-        execSync.mockReturnValue('https://github.com/Owner/Repo\n');
-        const result = getGitRepository();
-        expect(result).toEqual({
-            slug: 'Owner/Repo',
-            url: 'https://github.com/Owner/Repo',
-        });
-    });
-    it('parses GitLab SSH URL', () => {
-        ;
-        execSync.mockReturnValue('git@gitlab.com:My-Org/My-Project.git\n');
-        const result = getGitRepository();
-        expect(result).toEqual({
-            slug: 'My-Org/My-Project',
-            url: 'git@gitlab.com:My-Org/My-Project.git',
-        });
-    });
-    it('returns null when git command fails', () => {
-        ;
-        execSync.mockImplementation(() => {
-            throw new Error('no remote');
-        });
-        expect(getGitRepository()).toBeNull();
-    });
-    it('falls back to raw URL when regex does not match', () => {
-        ;
-        execSync.mockReturnValue('some-weird-url\n');
-        const result = getGitRepository();
-        expect(result).toEqual({
-            slug: 'some-weird-url',
-            url: 'some-weird-url',
-        });
-    });
-});
-describe('getProjectName', () => {
-    it('returns name from package.json when available', () => {
-        ;
-        fs.pathExistsSync.mockReturnValue(true);
-        fs.readJsonSync.mockReturnValue({ name: '@meltstudio/meltctl' });
-        expect(getProjectName()).toBe('@meltstudio/meltctl');
-    });
-    it('returns directory basename when package.json has no name', () => {
-        ;
-        fs.pathExistsSync.mockReturnValue(true);
-        fs.readJsonSync.mockReturnValue({});
-        const result = getProjectName();
-        // Should be the basename of cwd
-        expect(typeof result).toBe('string');
-        expect(result.length).toBeGreaterThan(0);
-    });
-    it('returns directory basename when package.json does not exist', () => {
-        ;
-        fs.pathExistsSync.mockReturnValue(false);
-        const result = getProjectName();
-        expect(typeof result).toBe('string');
-        expect(result.length).toBeGreaterThan(0);
-    });
-    it('returns directory basename when readJsonSync throws', () => {
-        ;
-        fs.pathExistsSync.mockReturnValue(true);
-        fs.readJsonSync.mockImplementation(() => {
-            throw new Error('parse error');
-        });
-        const result = getProjectName();
-        expect(typeof result).toBe('string');
-        expect(result.length).toBeGreaterThan(0);
-    });
-});
-describe('extractTicketId', () => {
-    it('extracts ticket ID from branch name', () => {
-        expect(extractTicketId('feature/PROJ-123-add-login')).toBe('PROJ-123');
-    });
-    it('extracts ticket ID case-insensitively', () => {
-        expect(extractTicketId('fix/proj-456')).toBe('proj-456');
-    });
-    it('returns null when no ticket ID found', () => {
-        expect(extractTicketId('main')).toBeNull();
-        expect(extractTicketId('feature/add-login')).toBeNull();
-    });
-});
-describe('findMdFiles', () => {
-    it('returns empty array when directory does not exist', async () => {
-        ;
-        fs.pathExists.mockResolvedValue(false);
-        const result = await findMdFiles('/nonexistent');
-        expect(result).toEqual([]);
-    });
-    it('finds and sorts .md files by mtime descending', async () => {
-        ;
-        fs.pathExists.mockResolvedValue(true);
-        fs.readdir.mockResolvedValue([
-            { name: 'old.md', isDirectory: () => false, isFile: () => true },
-            { name: 'new.md', isDirectory: () => false, isFile: () => true },
-            { name: 'not-md.txt', isDirectory: () => false, isFile: () => true },
-        ]);
-        fs.stat
-            .mockResolvedValueOnce({ mtimeMs: 1000 }) // old.md
-            .mockResolvedValueOnce({ mtimeMs: 2000 }); // new.md
-        const result = await findMdFiles('/test-dir');
-        expect(result).toEqual(['/test-dir/new.md', '/test-dir/old.md']);
-    });
-    it('recurses into subdirectories', async () => {
-        ;
-        fs.pathExists.mockResolvedValue(true);
-        fs.readdir
-            .mockResolvedValueOnce([
-            { name: 'sub', isDirectory: () => true, isFile: () => false },
-            { name: 'root.md', isDirectory: () => false, isFile: () => true },
-        ])
-            .mockResolvedValueOnce([{ name: 'nested.md', isDirectory: () => false, isFile: () => true }]);
-        fs.stat
-            .mockResolvedValueOnce({ mtimeMs: 4000 }) // sub/nested.md
-            .mockResolvedValueOnce({ mtimeMs: 3000 }); // root.md
-        const result = await findMdFiles('/project');
-        expect(result).toEqual(['/project/sub/nested.md', '/project/root.md']);
-    });
-});

package/dist/utils/package-manager.d.ts

@@ -1,7 +0,0 @@
-export type PackageManager = 'npm' | 'yarn' | 'unknown';
-export interface PackageManagerInfo {
-    type: PackageManager;
-    updateCommand: string;
-}
-export declare function detectPackageManager(): PackageManagerInfo;
-export declare function getUpdateInstructions(): string[];

package/dist/utils/package-manager.js

@@ -1,55 +0,0 @@
-import { execSync } from 'child_process';
-export function detectPackageManager() {
-    // Try to detect if meltctl is installed via npm or yarn
-    try {
-        // Check npm global installation
-        execSync('npm list -g @meltstudio/meltctl', {
-            encoding: 'utf-8',
-            stdio: 'pipe',
-        });
-        return {
-            type: 'npm',
-            updateCommand: 'npm install -g @meltstudio/meltctl@latest',
-        };
-    }
-    catch {
-        // npm check failed, try yarn
-    }
-    try {
-        // Check yarn global installation
-        execSync('yarn global list @meltstudio/meltctl', {
-            encoding: 'utf-8',
-            stdio: 'pipe',
-        });
-        return {
-            type: 'yarn',
-            updateCommand: 'yarn global add @meltstudio/meltctl@latest',
-        };
-    }
-    catch {
-        // yarn check failed
-    }
-    // Default to npm if detection fails
-    return {
-        type: 'unknown',
-        updateCommand: 'npm install -g @meltstudio/meltctl@latest',
-    };
-}
-export function getUpdateInstructions() {
-    const { type, updateCommand } = detectPackageManager();
-    if (type === 'npm') {
-        return [updateCommand, '', 'Or with yarn:', '  yarn global add @meltstudio/meltctl@latest'];
-    }
-    else if (type === 'yarn') {
-        return [updateCommand, '', 'Or with npm:', '  npm install -g @meltstudio/meltctl@latest'];
-    }
-    else {
-        // Unknown, show both options
-        return [
-            'npm install -g @meltstudio/meltctl@latest',
-            '',
-            'Or with yarn:',
-            '  yarn global add @meltstudio/meltctl@latest',
-        ];
-    }
-}

package/dist/utils/package-manager.test.d.ts

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

package/dist/utils/package-manager.test.js

@@ -1,76 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from 'vitest';
-vi.mock('child_process', () => ({
-    execSync: vi.fn(),
-}));
-import { execSync } from 'child_process';
-import { detectPackageManager, getUpdateInstructions } from './package-manager.js';
-beforeEach(() => {
-    vi.clearAllMocks();
-});
-describe('detectPackageManager', () => {
-    it('returns npm when npm list succeeds', () => {
-        vi.mocked(execSync).mockReturnValueOnce('');
-        const result = detectPackageManager();
-        expect(result).toEqual({
-            type: 'npm',
-            updateCommand: 'npm install -g @meltstudio/meltctl@latest',
-        });
-        expect(execSync).toHaveBeenCalledWith('npm list -g @meltstudio/meltctl', expect.objectContaining({ encoding: 'utf-8', stdio: 'pipe' }));
-    });
-    it('returns yarn when npm fails but yarn succeeds', () => {
-        vi.mocked(execSync)
-            .mockImplementationOnce(() => {
-            throw new Error('npm not found');
-        })
-            .mockReturnValueOnce('');
-        const result = detectPackageManager();
-        expect(result).toEqual({
-            type: 'yarn',
-            updateCommand: 'yarn global add @meltstudio/meltctl@latest',
-        });
-    });
-    it('returns unknown when both npm and yarn fail', () => {
-        vi.mocked(execSync)
-            .mockImplementationOnce(() => {
-            throw new Error('npm not found');
-        })
-            .mockImplementationOnce(() => {
-            throw new Error('yarn not found');
-        });
-        const result = detectPackageManager();
-        expect(result).toEqual({
-            type: 'unknown',
-            updateCommand: 'npm install -g @meltstudio/meltctl@latest',
-        });
-    });
-});
-describe('getUpdateInstructions', () => {
-    it('returns npm-first instructions when detected via npm', () => {
-        vi.mocked(execSync).mockReturnValueOnce('');
-        const instructions = getUpdateInstructions();
-        expect(instructions[0]).toBe('npm install -g @meltstudio/meltctl@latest');
-        expect(instructions.some(l => l.includes('yarn'))).toBe(true);
-    });
-    it('returns yarn-first instructions when detected via yarn', () => {
-        vi.mocked(execSync)
-            .mockImplementationOnce(() => {
-            throw new Error('npm not found');
-        })
-            .mockReturnValueOnce('');
-        const instructions = getUpdateInstructions();
-        expect(instructions[0]).toBe('yarn global add @meltstudio/meltctl@latest');
-        expect(instructions.some(l => l.includes('npm'))).toBe(true);
-    });
-    it('returns npm default instructions when detection fails', () => {
-        vi.mocked(execSync)
-            .mockImplementationOnce(() => {
-            throw new Error('npm not found');
-        })
-            .mockImplementationOnce(() => {
-            throw new Error('yarn not found');
-        });
-        const instructions = getUpdateInstructions();
-        expect(instructions[0]).toBe('npm install -g @meltstudio/meltctl@latest');
-        expect(instructions.some(l => l.includes('yarn'))).toBe(true);
-    });
-});

package/dist/utils/templates.d.ts

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

package/dist/utils/templates.js

@@ -1,5 +0,0 @@
-import { getClient } from './api.js';
-export async function fetchTemplates() {
-    const client = await getClient();
-    return client.templates.fetch();
-}

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

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

package/dist/utils/templates.test.js

@@ -1,38 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from 'vitest';
-const mockClient = vi.hoisted(() => ({
-    templates: {
-        fetch: vi.fn(),
-    },
-}));
-vi.mock('./api.js', () => ({
-    getClient: vi.fn().mockResolvedValue(mockClient),
-}));
-import { fetchTemplates } from './templates.js';
-beforeEach(() => {
-    vi.clearAllMocks();
-});
-describe('fetchTemplates', () => {
-    it('returns template files on success', async () => {
-        const mockFiles = {
-            'AGENTS.md': '# Agents content',
-            '.claude/skills/setup.md': '# Setup skill',
-        };
-        mockClient.templates.fetch.mockResolvedValue(mockFiles);
-        const result = await fetchTemplates();
-        expect(mockClient.templates.fetch).toHaveBeenCalled();
-        expect(result).toEqual(mockFiles);
-    });
-    it('throws error when API returns failure', async () => {
-        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 () => {
-        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 client.templates.fetch', async () => {
-        mockClient.templates.fetch.mockResolvedValue({});
-        await fetchTemplates();
-        expect(mockClient.templates.fetch).toHaveBeenCalledTimes(1);
-    });
-});

package/dist/utils/version-check.d.ts

@@ -1,7 +0,0 @@
-export declare function getCurrentCliVersion(): Promise<string>;
-export declare function getLatestCliVersion(): Promise<string | null>;
-export declare function compareVersions(current: string, latest: string): boolean;
-export declare function isCI(): boolean;
-export type UpdateSeverity = 'none' | 'patch' | 'minor' | 'major';
-export declare function getUpdateSeverity(current: string, latest: string): UpdateSeverity;
-export declare function checkAndEnforceUpdate(): Promise<void>;

package/dist/utils/version-check.js

@@ -1,139 +0,0 @@
-import chalk from 'chalk';
-import { confirm } from '@inquirer/prompts';
-import { execSync } from 'child_process';
-import fs from 'fs-extra';
-import path from 'path';
-import { fileURLToPath } from 'url';
-const __dirname = path.dirname(fileURLToPath(import.meta.url));
-export async function getCurrentCliVersion() {
-    const packagePath = path.join(__dirname, '../../package.json');
-    const packageJson = await fs.readJson(packagePath);
-    return packageJson.version;
-}
-export async function getLatestCliVersion() {
-    try {
-        const result = execSync('npm view @meltstudio/meltctl version --json', {
-            encoding: 'utf-8',
-            stdio: 'pipe',
-            timeout: 5000, // 5 second timeout
-        });
-        return JSON.parse(result.trim());
-    }
-    catch {
-        // Network error or timeout - return null to indicate check failed
-        return null;
-    }
-}
-export function compareVersions(current, latest) {
-    // Parse semver strings, handling pre-release tags
-    const parseVersion = (version) => {
-        const [base, prerelease] = version.split('-');
-        const parts = (base || '').split('.').map(Number);
-        return {
-            major: parts[0] || 0,
-            minor: parts[1] || 0,
-            patch: parts[2] || 0,
-            prerelease: prerelease || null,
-        };
-    };
-    const currentVer = parseVersion(current);
-    const latestVer = parseVersion(latest);
-    // Compare major.minor.patch first
-    if (latestVer.major !== currentVer.major) {
-        return latestVer.major > currentVer.major;
-    }
-    if (latestVer.minor !== currentVer.minor) {
-        return latestVer.minor > currentVer.minor;
-    }
-    if (latestVer.patch !== currentVer.patch) {
-        return latestVer.patch > currentVer.patch;
-    }
-    // If base versions are equal, handle pre-release comparison
-    // No pre-release (stable) > pre-release
-    if (!latestVer.prerelease && currentVer.prerelease)
-        return true;
-    if (latestVer.prerelease && !currentVer.prerelease)
-        return false;
-    // Both have pre-release or both are stable
-    if (latestVer.prerelease && currentVer.prerelease) {
-        return latestVer.prerelease > currentVer.prerelease;
-    }
-    return false; // Versions are equal
-}
-export function isCI() {
-    // Check common CI environment variables
-    return !!(process.env.CI || // Generic CI flag
-        process.env.GITHUB_ACTIONS || // GitHub Actions
-        process.env.GITLAB_CI || // GitLab CI
-        process.env.CIRCLECI || // CircleCI
-        process.env.TRAVIS || // Travis CI
-        process.env.JENKINS_URL || // Jenkins
-        process.env.BUILDKITE || // Buildkite
-        process.env.DRONE || // Drone
-        process.env.MELTCTL_SKIP_UPDATE_CHECK // Custom override
-    );
-}
-export function getUpdateSeverity(current, latest) {
-    const parseCurrent = current.split('-')[0].split('.').map(Number);
-    const parseLatest = latest.split('-')[0].split('.').map(Number);
-    const [curMajor = 0, curMinor = 0, curPatch = 0] = parseCurrent;
-    const [latMajor = 0, latMinor = 0, latPatch = 0] = parseLatest;
-    if (latMajor > curMajor)
-        return 'major';
-    if (latMajor === curMajor && latMinor > curMinor)
-        return 'minor';
-    if (latMajor === curMajor && latMinor === curMinor && latPatch > curPatch)
-        return 'patch';
-    return 'none';
-}
-export async function checkAndEnforceUpdate() {
-    // Skip update check in CI environments
-    if (isCI()) {
-        return;
-    }
-    try {
-        const currentVersion = await getCurrentCliVersion();
-        const latestVersion = await getLatestCliVersion();
-        // If we can't fetch latest version (network error), allow continuing
-        if (!latestVersion) {
-            return;
-        }
-        const severity = getUpdateSeverity(currentVersion, latestVersion);
-        if (severity === 'none') {
-            return;
-        }
-        if (severity === 'patch') {
-            // Patch updates: warn but allow continuing
-            console.log();
-            console.log(chalk.yellow(`  Update available: ${currentVersion} → ${latestVersion} (run: meltctl update)`));
-            console.log();
-            return;
-        }
-        // Minor/major updates: offer to update, block if declined
-        console.log();
-        console.log(chalk.yellow(`  Update required: ${currentVersion} → ${latestVersion}`));
-        console.log();
-        const shouldUpdate = await confirm({
-            message: 'Update now?',
-            default: true,
-        });
-        if (shouldUpdate) {
-            const { updateCommand } = await import('../commands/update.js');
-            await updateCommand();
-            // Re-run the original command after update
-            console.log();
-            console.log(chalk.dim('  Please re-run your command.'));
-            console.log();
-            process.exit(0);
-        }
-        console.log();
-        console.log(chalk.gray('To skip this check (CI/CD), set MELTCTL_SKIP_UPDATE_CHECK=1'));
-        console.log();
-        process.exit(1);
-    }
-    catch {
-        // If any error occurs during version check, allow continuing
-        // This ensures the CLI remains usable even if version check fails
-        return;
-    }
-}

package/dist/utils/version-check.test.d.ts

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