@meltstudio/meltctl 2.4.1 → 4.0.0

package/dist/commands/init.d.ts

@@ -0,0 +1,5 @@
+interface InitOptions {
+    force?: boolean;
+}
+export declare function initCommand(options: InitOptions): Promise<void>;
+export {};

package/dist/commands/init.js

@@ -0,0 +1,149 @@
+import chalk from 'chalk';
+import fs from 'fs-extra';
+import path from 'path';
+import { authenticatedFetch, isAuthenticated } from '../utils/auth.js';
+const SKILL_FRONTMATTER = {
+    plan: `---
+user-invocable: true
+description: Design an implementation approach before writing code
+---
+
+`,
+    review: `---
+user-invocable: true
+description: Review changes against project standards
+---
+
+`,
+    pr: `---
+user-invocable: true
+description: Create a well-structured pull request
+---
+
+`,
+    debug: `---
+user-invocable: true
+description: Systematically investigate and fix bugs
+---
+
+`,
+};
+const GITIGNORE_ENTRIES = ['.env.local', '.claude/settings.local.json'];
+async function fetchTemplates() {
+    const response = await authenticatedFetch('/templates');
+    if (!response.ok) {
+        throw new Error(`Failed to fetch templates: ${response.statusText}`);
+    }
+    const data = (await response.json());
+    return data.files;
+}
+export async function initCommand(options) {
+    const cwd = process.cwd();
+    // Check if already initialized (AGENTS.md exists)
+    if (!options.force && (await fs.pathExists(path.join(cwd, 'AGENTS.md')))) {
+        console.log(chalk.yellow('Project already has an AGENTS.md file. Use --force to overwrite.'));
+        process.exit(1);
+    }
+    // Require authentication
+    if (!(await isAuthenticated())) {
+        console.error(chalk.red('Not authenticated. Run `meltctl login` first.'));
+        process.exit(1);
+    }
+    let templates;
+    try {
+        templates = await fetchTemplates();
+    }
+    catch (error) {
+        if (error instanceof Error && error.message.includes('expired')) {
+            console.error(chalk.red('Session expired. Run `meltctl login` to re-authenticate.'));
+        }
+        else if (error instanceof Error && error.message.includes('fetch')) {
+            console.error(chalk.red('Could not reach Melt API. Check your connection.'));
+        }
+        else {
+            console.error(chalk.red(`Failed to fetch templates: ${error instanceof Error ? error.message : 'Unknown error'}`));
+        }
+        process.exit(1);
+    }
+    console.log(chalk.bold('Initializing Melt development tools...'));
+    console.log();
+    // Copy AGENTS.md
+    const agentsMd = templates['agents-md.md'];
+    if (agentsMd) {
+        await fs.writeFile(path.join(cwd, 'AGENTS.md'), agentsMd, 'utf-8');
+    }
+    // Copy .claude/settings.json
+    const claudeSettings = templates['claude-settings.json'];
+    if (claudeSettings) {
+        await fs.ensureDir(path.join(cwd, '.claude'));
+        await fs.writeFile(path.join(cwd, '.claude/settings.json'), claudeSettings, 'utf-8');
+    }
+    // Create Claude skills from workflow templates
+    const workflows = ['plan', 'review', 'pr', 'debug'];
+    for (const name of workflows) {
+        const workflowContent = templates[`workflows/${name}.md`];
+        if (workflowContent) {
+            const skillDir = path.join(cwd, `.claude/skills/melt-${name}`);
+            await fs.ensureDir(skillDir);
+            const skillContent = SKILL_FRONTMATTER[name] + workflowContent;
+            await fs.writeFile(path.join(skillDir, 'SKILL.md'), skillContent, 'utf-8');
+        }
+    }
+    // Copy .cursor/rules/standards.mdc
+    const cursorRules = templates['cursor-rules.mdc'];
+    if (cursorRules) {
+        await fs.ensureDir(path.join(cwd, '.cursor/rules'));
+        await fs.writeFile(path.join(cwd, '.cursor/rules/standards.mdc'), cursorRules, 'utf-8');
+    }
+    // Copy Cursor commands from workflow templates
+    await fs.ensureDir(path.join(cwd, '.cursor/commands'));
+    for (const name of workflows) {
+        const workflowContent = templates[`workflows/${name}.md`];
+        if (workflowContent) {
+            await fs.writeFile(path.join(cwd, `.cursor/commands/melt-${name}.md`), workflowContent, 'utf-8');
+        }
+    }
+    // Copy .mcp.json
+    const mcpConfig = templates['mcp-configs/base.json'];
+    if (mcpConfig) {
+        await fs.writeFile(path.join(cwd, '.mcp.json'), mcpConfig, 'utf-8');
+    }
+    // Copy .env.melt.example
+    const envExample = templates['env-melt-example'];
+    if (envExample) {
+        await fs.writeFile(path.join(cwd, '.env.melt.example'), envExample, 'utf-8');
+    }
+    // Update .gitignore
+    await updateGitignore(cwd);
+    // Print summary
+    console.log(chalk.green('Created files:'));
+    console.log(chalk.dim('  AGENTS.md'));
+    console.log(chalk.dim('  .claude/settings.json'));
+    console.log(chalk.dim('  .claude/skills/melt-{plan,review,pr,debug}/SKILL.md'));
+    console.log(chalk.dim('  .cursor/rules/standards.mdc'));
+    console.log(chalk.dim('  .cursor/commands/melt-{plan,review,pr,debug}.md'));
+    console.log(chalk.dim('  .mcp.json'));
+    console.log(chalk.dim('  .env.melt.example'));
+    console.log();
+    console.log(chalk.yellow('Next steps:'));
+    console.log(chalk.dim('  1. Edit AGENTS.md to describe your project and add team-specific standards'));
+    console.log(chalk.dim('  2. Copy .env.melt.example to .env.local and fill in credentials'));
+    console.log(chalk.dim('  3. Commit the generated files'));
+    console.log();
+    console.log(chalk.green('Done!'));
+}
+async function updateGitignore(cwd) {
+    const gitignorePath = path.join(cwd, '.gitignore');
+    let content = '';
+    if (await fs.pathExists(gitignorePath)) {
+        content = await fs.readFile(gitignorePath, 'utf-8');
+    }
+    const missingEntries = GITIGNORE_ENTRIES.filter(entry => !content.includes(entry));
+    if (missingEntries.length > 0) {
+        const suffix = content.endsWith('\n') || content === '' ? '' : '\n';
+        const section = missingEntries.length > 0
+            ? `${suffix}\n# Melt - local settings\n${missingEntries.join('\n')}\n`
+            : '';
+        await fs.writeFile(gitignorePath, content + section, 'utf-8');
+    }
+}

package/dist/commands/login.d.ts

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

package/dist/commands/login.js

@@ -0,0 +1,90 @@
+import chalk from 'chalk';
+import http from 'http';
+import { URL } from 'url';
+import { exec } from 'child_process';
+import { API_BASE, storeAuth } from '../utils/auth.js';
+import { printBanner } from '../utils/banner.js';
+const LOGIN_TIMEOUT_MS = 60_000;
+function openBrowser(url) {
+    const command = process.platform === 'darwin' ? 'open' : process.platform === 'win32' ? 'start' : 'xdg-open';
+    exec(`${command} "${url}"`);
+}
+function findFreePort() {
+    return new Promise((resolve, reject) => {
+        const server = http.createServer();
+        server.listen(0, () => {
+            const address = server.address();
+            if (address && typeof address === 'object') {
+                const port = address.port;
+                server.close(() => resolve(port));
+            }
+            else {
+                reject(new Error('Could not find free port'));
+            }
+        });
+    });
+}
+export async function loginCommand() {
+    printBanner();
+    console.log(chalk.bold('  Logging in to Melt...'));
+    const port = await findFreePort();
+    const redirectUri = `http://localhost:${port.toString()}`;
+    const authCode = await new Promise((resolve, reject) => {
+        const timeout = setTimeout(() => {
+            server.close();
+            reject(new Error('Authentication timed out. Please try again.'));
+        }, LOGIN_TIMEOUT_MS);
+        const server = http.createServer((req, res) => {
+            const url = new URL(req.url ?? '/', `http://localhost:${port.toString()}`);
+            const code = url.searchParams.get('code');
+            const error = url.searchParams.get('error');
+            if (error) {
+                res.writeHead(200, { 'Content-Type': 'text/html' });
+                res.end('<html><body><h2>Authentication failed</h2><p>You can close this tab.</p></body></html>');
+                clearTimeout(timeout);
+                server.close();
+                reject(new Error(`Authentication denied: ${error}`));
+                return;
+            }
+            if (!code) {
+                res.writeHead(400, { 'Content-Type': 'text/html' });
+                res.end('<html><body><h2>Missing authorization code</h2></body></html>');
+                return;
+            }
+            res.writeHead(200, { 'Content-Type': 'text/html' });
+            res.end('<html><body><h2>Authentication successful!</h2><p>You can close this tab and return to your terminal.</p></body></html>');
+            clearTimeout(timeout);
+            server.close();
+            resolve(code);
+        });
+        server.listen(port, () => {
+            const authUrl = `${API_BASE}/auth/google?redirect_uri=${encodeURIComponent(redirectUri)}`;
+            console.log(chalk.dim('Opening browser for authentication...'));
+            openBrowser(authUrl);
+            console.log(chalk.dim(`If the browser doesn't open, visit: ${authUrl}`));
+        });
+    });
+    console.log(chalk.dim('Exchanging authorization code...'));
+    const response = await fetch(`${API_BASE}/auth/token`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ code: authCode, redirect_uri: redirectUri }),
+    });
+    if (!response.ok) {
+        const error = (await response.json());
+        if (response.status === 403) {
+            console.error(chalk.red('Only @meltstudio.co accounts can use this tool.'));
+            process.exit(1);
+        }
+        console.error(chalk.red(`Authentication failed: ${error.error ?? 'Unknown error'}`));
+        process.exit(1);
+    }
+    const data = (await response.json());
+    await storeAuth({
+        token: data.token,
+        email: data.email,
+        expiresAt: data.expiresAt,
+    });
+    console.log();
+    console.log(chalk.green(`Logged in as ${data.email}`));
+}

package/dist/commands/logout.d.ts

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

package/dist/commands/logout.js

@@ -0,0 +1,12 @@
+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/index.js

@@ -3,9 +3,10 @@ import { Command } from '@commander-js/extra-typings';
 import { readFileSync } from 'fs';
 import { join, dirname } from 'path';
 import { fileURLToPath } from 'url';
-import { initCommand } from './commands/project/init.js';
-import { updateCommand } from './commands/project/update.js';
-import { cleanCommand } from './commands/project/clean.js';
+import { initCommand } from './commands/init.js';
+import { loginCommand } from './commands/login.js';
+import { logoutCommand } from './commands/logout.js';
+import { printBanner } from './utils/banner.js';
 import { checkAndEnforceUpdate } from './utils/version-check.js';
 import { versionCheckCommand } from './commands/version.js';
 // Read version from package.json
@@ -15,43 +16,39 @@ const packageJson = JSON.parse(readFileSync(join(__dirname, '../package.json'),
 const program = new Command();
 program
     .name('meltctl')
-    .description('CLI tool for Melt development process automation')
+    .description('Set up AI-first development standards (AGENTS.md, Claude skills, Cursor rules, MCP config) in your project.\n\nRequires a @meltstudio.co Google Workspace account. Run `meltctl login` first, then `meltctl project init` in your repo.')
     .version(packageJson.version)
+    .addHelpText('beforeAll', () => {
+    printBanner();
+    return '';
+})
     .hook('preAction', async () => {
     await checkAndEnforceUpdate();
 });
-// Project management commands
-const projectCommand = program
-    .command('project')
-    .description('Project setup and management commands');
-projectCommand
-    .command('init')
-    .description('Initialize project with Melt development tools')
-    .option('--shell <type>', 'specify shell type (sh|ps)', 'auto')
-    .action(options => {
-    // Validate shell option
-    const validShells = ['sh', 'ps', 'auto'];
-    const shell = validShells.includes(options.shell)
-        ? options.shell
-        : 'auto';
-    return initCommand({ shell });
+program
+    .command('login')
+    .description('authenticate with Google Workspace (opens browser)')
+    .action(async () => {
+    await loginCommand();
 });
-projectCommand
-    .command('update')
-    .description('Update project configurations to latest version')
-    .action(updateCommand);
-projectCommand
-    .command('clean')
-    .description('Remove all Melt-generated files from the project')
-    .option('-y, --yes', 'skip confirmation prompt')
+program
+    .command('logout')
+    .description('clear stored credentials from ~/.meltctl/')
+    .action(async () => {
+    await logoutCommand();
+});
+const project = program.command('project').description('manage project configuration');
+project
+    .command('init')
+    .description('scaffold Melt development tools into the current directory (AGENTS.md, .claude/, .cursor/, .mcp.json)')
+    .option('--force', 'overwrite existing files if already initialized')
     .action(options => {
-    return cleanCommand({ yes: options.yes });
+    return initCommand({ force: options.force });
 });
-// Version check command
 program
     .command('version')
-    .description('Display version information')
-    .option('--check', 'check for updates')
+    .description('show current version')
+    .option('--check', 'also check for available updates')
     .action(async (options) => {
     if (options.check) {
         await versionCheckCommand();

package/dist/utils/auth.d.ts

@@ -0,0 +1,12 @@
+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): Promise<Response>;
+export {};

package/dist/utils/auth.js

@@ -0,0 +1,52 @@
+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) {
+    const auth = await getStoredAuth();
+    if (!auth) {
+        throw new Error('Not authenticated. Run `meltctl login` first.');
+    }
+    if (new Date(auth.expiresAt) <= new Date()) {
+        throw new Error('Session expired. Run `meltctl login` to re-authenticate.');
+    }
+    const response = await fetch(`${API_BASE}${urlPath}`, {
+        headers: {
+            Authorization: `Bearer ${auth.token}`,
+        },
+    });
+    if (response.status === 401) {
+        throw new Error('Session expired. Run `meltctl login` to re-authenticate.');
+    }
+    return response;
+}

package/dist/utils/banner.d.ts

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

package/dist/utils/banner.js

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

@@ -1,7 +1,7 @@
 {
   "name": "@meltstudio/meltctl",
-  "version": "2.4.1",
-  "description": "CLI tool for Melt development process automation - initialize and update project configurations",
+  "version": "4.0.0",
+  "description": "AI-first development tools for teams - set up AGENTS.md, Claude Code, Cursor, and Copilot standards",
   "main": "dist/index.js",
   "type": "module",
   "bin": {
@@ -9,7 +9,6 @@
   },
   "files": [
     "dist/**/*",
-    "templates/**/*",
     "README.md",
     "LICENSE"
   ],
@@ -37,7 +36,10 @@
   "keywords": [
     "cli",
     "development-tools",
+    "agents-md",
+    "claude-code",
     "cursor",
+    "copilot",
     "ai-development",
     "melt",
     "automation"
@@ -45,12 +47,11 @@
   "author": "Melt Studio",
   "license": "MIT",
   "dependencies": {
-    "@clack/prompts": "^0.9.0",
-    "commander": "^12.1.0",
     "@commander-js/extra-typings": "^12.1.0",
     "chalk": "^5.4.1",
-    "ora": "^8.2.0",
-    "fs-extra": "^11.2.0"
+    "commander": "^12.1.0",
+    "fs-extra": "^11.2.0",
+    "gradient-string": "^3.0.0"
   },
   "devDependencies": {
     "@types/fs-extra": "^11.0.4",

package/dist/commands/project/clean.d.ts

@@ -1,5 +0,0 @@
-interface CleanOptions {
-    yes?: boolean;
-}
-export declare function cleanCommand(options?: CleanOptions): Promise<void>;
-export {};