@meltstudio/meltctl 4.31.0 → 4.33.0

package/dist/commands/init.js

@@ -117,6 +117,16 @@ description: >-
   This is a reference skill — it explains the process, not executes it.
 ---
 
+`,
+    link: `---
+user-invocable: true
+description: >-
+  Connect and verify required integrations (ticket tracker, browser
+  testing). Use after melt-setup, when tools aren't working, or when
+  a skill reports missing MCP connections. Guides setup, verifies
+  each tool works, and updates AGENTS.md connection status.
+---
+
 `,
 };
 const OPENCODE_COMMAND_FRONTMATTER = {
@@ -174,6 +184,11 @@ description: Update Melt skills and standards to the latest version.
 description: Answer questions about the AI-First Development Playbook and team workflow.
 ---
 
+`,
+    link: `---
+description: Connect and verify required integrations (ticket tracker, browser testing).
+---
+
 `,
 };
 const GITIGNORE_ENTRIES = ['.env.local', '.claude/settings.local.json'];
@@ -321,6 +336,7 @@ export async function initCommand(options) {
         'security-audit',
         'update',
         'help',
+        'link',
     ];
     // Shared files (skip on re-init)
     if (!isReInit) {
@@ -443,7 +459,7 @@ export async function initCommand(options) {
         }
         console.log();
         console.log(chalk.dim('  The setup skill will analyze your project and fill in AGENTS.md.'));
-        console.log(chalk.dim('  Once it finishes, commit the changes to share with your team.'));
+        console.log(chalk.dim('  Then run /melt-link to connect your ticket tracker and browser testing tools.'));
         console.log();
     }
     console.log(chalk.green('Done!'));

package/dist/commands/init.test.js

@@ -36,6 +36,7 @@ const MOCK_TEMPLATES = {
     'workflows/security-audit.md': '# Security Audit Workflow\nSecurity check.',
     'workflows/update.md': '# Update Workflow\nUpdate skills.',
     'workflows/help.md': '# Help Workflow\nAnswer questions.',
+    'workflows/link.md': '# Link Workflow\nConnect tools.',
     'claude-settings.json': '{"permissions":{"allow":["Read"],"deny":["Bash"]}}',
     'mcp-configs/base.json': '{"mcpServers":{"context7":{"command":"npx","args":["context7"]}}}',
 };
@@ -114,13 +115,13 @@ describe('initCommand', () => {
             // Verify ensureDir was called for skill directories
             const ensureDirCalls = fs.ensureDir.mock.calls;
             const skillDirs = ensureDirCalls.filter(c => c[0].includes('.claude/skills/melt-'));
-            expect(skillDirs.length).toBeGreaterThanOrEqual(11);
+            expect(skillDirs.length).toBeGreaterThanOrEqual(12);
         });
         it('creates all 11 Claude skills', async () => {
             await initCommand({ claude: true });
             const writeCalls = fs.writeFile.mock.calls;
             const skillFiles = writeCalls.filter(c => c[0].includes('.claude/skills/melt-') && c[0].endsWith('SKILL.md'));
-            expect(skillFiles.length).toBe(11);
+            expect(skillFiles.length).toBe(12);
             const skillNames = skillFiles.map(c => {
                 const match = c[0].match(/\.claude\/skills\/melt-([^/]+)/);
                 return match ? match[1] : '';
@@ -136,12 +137,13 @@ describe('initCommand', () => {
             expect(skillNames).toContain('security-audit');
             expect(skillNames).toContain('update');
             expect(skillNames).toContain('help');
+            expect(skillNames).toContain('link');
         });
         it('creates Cursor commands without frontmatter', async () => {
             await initCommand({ cursor: true });
             const writeCalls = fs.writeFile.mock.calls;
             const cursorFiles = writeCalls.filter(c => c[0].includes('.cursor/commands/melt-'));
-            expect(cursorFiles.length).toBe(11);
+            expect(cursorFiles.length).toBe(12);
             // Cursor commands should NOT have frontmatter
             const setupCmd = cursorFiles.find(c => c[0].includes('melt-setup.md'));
             expect(setupCmd).toBeDefined();
@@ -152,7 +154,7 @@ describe('initCommand', () => {
             await initCommand({ opencode: true });
             const writeCalls = fs.writeFile.mock.calls;
             const opencodeFiles = writeCalls.filter(c => c[0].includes('.opencode/commands/melt-'));
-            expect(opencodeFiles.length).toBe(11);
+            expect(opencodeFiles.length).toBe(12);
             // OpenCode commands should have shorter frontmatter
             const setupCmd = opencodeFiles.find(c => c[0].includes('melt-setup.md'));
             expect(setupCmd).toBeDefined();

package/dist/index.js

@@ -16,6 +16,7 @@ import { feedbackCommand } from './commands/feedback.js';
 import { coinsCommand } from './commands/coins.js';
 import { auditSubmitCommand, auditListCommand, auditViewCommand } from './commands/audit.js';
 import { planSubmitCommand, planListCommand } from './commands/plan.js';
+import { trackCommand } from './utils/analytics.js';
 // Read version from package.json
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
@@ -32,6 +33,7 @@ program
     .addHelpText('after', `
 ${chalk.bold('AI Skills')} ${chalk.dim('(run these in your AI coding tool, not the CLI):')}
 ${chalk.dim('  /melt-setup            Analyze the project and customize AGENTS.md')}
+${chalk.dim('  /melt-link             Connect and verify ticket tracker + browser testing')}
 ${chalk.dim('  /melt-plan             Design an implementation approach before writing code')}
 ${chalk.dim('  /melt-validate         Run the validation plan and verify end-to-end')}
 ${chalk.dim('  /melt-review           Review changes against project standards')}
@@ -45,6 +47,20 @@ ${chalk.dim('  /melt-help             Answer questions about the development pla
 `)
     .hook('preAction', async () => {
     await checkAndEnforceUpdate();
+})
+    .hook('postAction', (_thisCommand, actionCommand) => {
+    try {
+        const parts = [];
+        let cmd = actionCommand;
+        while (cmd && cmd.name() !== 'meltctl') {
+            parts.unshift(cmd.name());
+            cmd = cmd.parent;
+        }
+        trackCommand(parts.join(' '), true);
+    }
+    catch {
+        // Analytics must never break the CLI
+    }
 });
 program
     .command('login')
@@ -64,6 +80,7 @@ const project = program
     .addHelpText('after', `
 ${chalk.dim('Related skills (run in your AI coding tool after init):')}
 ${chalk.dim('  /melt-setup    Analyze the project and customize AGENTS.md')}
+${chalk.dim('  /melt-link     Connect and verify ticket tracker + browser testing')}
 ${chalk.dim('  /melt-update   Update Melt skills to the latest version')}
 `);
 project
@@ -183,6 +200,11 @@ program
 });
 program.parseAsync(process.argv).catch((error) => {
     const message = error instanceof Error ? error.message : 'An unexpected error occurred';
+    const commandName = process.argv
+        .slice(2)
+        .filter(a => !a.startsWith('-'))
+        .join(' ') || 'unknown';
+    trackCommand(commandName, false, message);
     console.error(chalk.red(message));
     process.exit(1);
 });

package/dist/utils/analytics.d.ts

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

package/dist/utils/analytics.js

@@ -0,0 +1,44 @@
+import { readFileSync } from 'fs';
+import { join, dirname } from 'path';
+import { fileURLToPath } from 'url';
+import { getStoredAuth, API_BASE } from './auth.js';
+import { getGitRepository, getGitBranch, getProjectName } from './git.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 {
+        const auth = await getStoredAuth();
+        if (!auth || new Date(auth.expiresAt) <= new Date()) {
+            return;
+        }
+        const repo = getGitRepository();
+        fetch(`${API_BASE}/events`, {
+            method: 'POST',
+            headers: {
+                Authorization: `Bearer ${auth.token}`,
+                'Content-Type': 'application/json',
+            },
+            body: JSON.stringify({
+                command,
+                project: getProjectName(),
+                repository: repo?.slug ?? null,
+                branch: getGitBranch(),
+                version: getVersion(),
+                success,
+                errorMessage: errorMessage?.slice(0, 500) ?? null,
+            }),
+        }).catch(() => { });
+    }
+    catch {
+        // Analytics must never break the CLI
+    }
+}

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

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

package/dist/utils/analytics.test.js

@@ -0,0 +1,91 @@
+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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@meltstudio/meltctl",
-  "version": "4.31.0",
+  "version": "4.33.0",
   "description": "AI-first development tools for teams - set up AGENTS.md, Claude Code, Cursor, and OpenCode standards",
   "main": "dist/index.js",
   "type": "module",