@kylewadegrove/cutline-mcp-cli 0.4.2 → 0.5.0

package/dist/commands/setup.js

@@ -0,0 +1,255 @@
+import chalk from 'chalk';
+import ora from 'ora';
+import { createInterface } from 'node:readline';
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join, dirname, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { getRefreshToken } from '../auth/keychain.js';
+import { fetchFirebaseApiKey } from '../utils/config.js';
+import { loginCommand } from './login.js';
+import { initCommand } from './init.js';
+function getCliVersion() {
+    try {
+        const __filename = fileURLToPath(import.meta.url);
+        const pkg = JSON.parse(readFileSync(join(dirname(__filename), '..', '..', 'package.json'), 'utf-8'));
+        return pkg.version ?? 'unknown';
+    }
+    catch {
+        return 'unknown';
+    }
+}
+const SERVER_NAMES = [
+    'constraints',
+    'premortem',
+    'exploration',
+    'tools',
+    'output',
+    'integrations',
+];
+async function detectTier(options) {
+    const refreshToken = await getRefreshToken();
+    if (!refreshToken)
+        return { tier: 'free' };
+    try {
+        const apiKey = await fetchFirebaseApiKey(options);
+        const response = await fetch(`https://securetoken.googleapis.com/v1/token?key=${apiKey}`, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({ grant_type: 'refresh_token', refresh_token: refreshToken }),
+        });
+        if (!response.ok)
+            return { tier: 'free' };
+        const data = await response.json();
+        const idToken = data.id_token;
+        const payload = JSON.parse(Buffer.from(idToken.split('.')[1], 'base64').toString());
+        const baseUrl = options.staging
+            ? 'https://us-central1-cutline-staging.cloudfunctions.net'
+            : 'https://us-central1-cutline-prod.cloudfunctions.net';
+        const subRes = await fetch(`${baseUrl}/mcpSubscriptionStatus`, {
+            headers: { Authorization: `Bearer ${idToken}` },
+        });
+        const sub = subRes.ok ? await subRes.json() : { status: 'free' };
+        const isPremium = sub.status === 'active' || sub.status === 'trialing';
+        return { tier: isPremium ? 'premium' : 'free', email: payload.email, idToken };
+    }
+    catch {
+        return { tier: 'free' };
+    }
+}
+async function fetchProducts(idToken, options) {
+    try {
+        const baseUrl = options.staging
+            ? 'https://us-central1-cutline-staging.cloudfunctions.net'
+            : 'https://us-central1-cutline-prod.cloudfunctions.net';
+        const res = await fetch(`${baseUrl}/mcpListProducts`, {
+            headers: { Authorization: `Bearer ${idToken}` },
+        });
+        if (!res.ok)
+            return [];
+        const data = await res.json();
+        return data.products ?? [];
+    }
+    catch {
+        return [];
+    }
+}
+function prompt(question) {
+    const rl = createInterface({ input: process.stdin, output: process.stdout });
+    return new Promise((resolve) => {
+        rl.question(question, (answer) => {
+            rl.close();
+            resolve(answer.trim());
+        });
+    });
+}
+function buildServerConfig() {
+    const config = {};
+    for (const name of SERVER_NAMES) {
+        config[`cutline-${name}`] = {
+            command: 'npx',
+            args: ['-y', '@kylewadegrove/cutline-mcp-cli@latest', 'serve', name],
+        };
+    }
+    return config;
+}
+function mergeIdeConfig(filePath, serverConfig) {
+    let existing = {};
+    if (existsSync(filePath)) {
+        try {
+            existing = JSON.parse(readFileSync(filePath, 'utf-8'));
+        }
+        catch {
+            existing = {};
+        }
+    }
+    else {
+        const dir = join(filePath, '..');
+        mkdirSync(dir, { recursive: true });
+    }
+    const existingServers = (existing.mcpServers ?? {});
+    // Remove old cutline-* entries, then add fresh ones
+    const cleaned = {};
+    for (const [key, val] of Object.entries(existingServers)) {
+        if (!key.startsWith('cutline-')) {
+            cleaned[key] = val;
+        }
+    }
+    existing.mcpServers = { ...cleaned, ...serverConfig };
+    writeFileSync(filePath, JSON.stringify(existing, null, 2) + '\n');
+    return true;
+}
+export async function setupCommand(options) {
+    const version = getCliVersion();
+    console.log(chalk.bold(`\n🔌 Cutline MCP Setup`) + chalk.dim(` v${version}\n`));
+    // ── 1. Authenticate ──────────────────────────────────────────────────────
+    const hasToken = await getRefreshToken();
+    if (!hasToken && !options.skipLogin) {
+        console.log(chalk.dim('  No credentials found — starting login flow.\n'));
+        await loginCommand({ staging: options.staging });
+        console.log();
+    }
+    const spinner = ora('Detecting account tier...').start();
+    const { tier, email, idToken } = await detectTier({ staging: options.staging });
+    if (email) {
+        spinner.succeed(chalk.green(`Authenticated as ${email} (${tier})`));
+    }
+    else {
+        spinner.succeed(chalk.yellow(`Running as ${tier} tier`));
+    }
+    console.log();
+    // ── 2. Connect to a product graph ────────────────────────────────────────
+    const projectRoot = resolve(options.projectRoot ?? process.cwd());
+    const configPath = join(projectRoot, '.cutline', 'config.json');
+    const hasExistingConfig = existsSync(configPath);
+    if (tier === 'premium' && idToken && !hasExistingConfig) {
+        const productSpinner = ora('Fetching your product graphs...').start();
+        const products = await fetchProducts(idToken, { staging: options.staging });
+        productSpinner.stop();
+        if (products.length > 0) {
+            console.log(chalk.bold('  Connect to a product graph\n'));
+            products.forEach((p, i) => {
+                const date = p.createdAt ? chalk.dim(` (${new Date(p.createdAt).toLocaleDateString()})`) : '';
+                console.log(`  ${chalk.cyan(`${i + 1}.`)} ${chalk.white(p.name)}${date}`);
+                if (p.brief)
+                    console.log(`     ${chalk.dim(p.brief)}`);
+            });
+            console.log(`  ${chalk.dim(`${products.length + 1}.`)} ${chalk.dim('Skip — I\'ll connect later')}`);
+            console.log();
+            const answer = await prompt(chalk.cyan('  Select a product (number): '));
+            const choice = parseInt(answer, 10);
+            if (choice >= 1 && choice <= products.length) {
+                const selected = products[choice - 1];
+                mkdirSync(join(projectRoot, '.cutline'), { recursive: true });
+                writeFileSync(configPath, JSON.stringify({
+                    product_id: selected.id,
+                    product_name: selected.name,
+                }, null, 2) + '\n');
+                console.log(chalk.green(`\n  ✓ Connected to "${selected.name}"`));
+                console.log(chalk.dim(`    ${configPath}\n`));
+            }
+            else {
+                console.log(chalk.dim('\n  Skipped. Run `cutline-mcp setup` again to connect later.\n'));
+            }
+        }
+    }
+    else if (hasExistingConfig) {
+        try {
+            const existing = JSON.parse(readFileSync(configPath, 'utf-8'));
+            console.log(chalk.green(`  ✓ Connected to product graph:`), chalk.white(existing.product_name || existing.product_id));
+            console.log();
+        }
+        catch { /* ignore parse errors */ }
+    }
+    // ── 3. Write MCP server config to IDEs ───────────────────────────────────
+    const serverConfig = buildServerConfig();
+    const home = homedir();
+    const ideConfigs = [
+        { name: 'Cursor', path: join(home, '.cursor', 'mcp.json') },
+        { name: 'Claude Code', path: join(home, '.claude', 'settings.json') },
+    ];
+    let wroteAny = false;
+    for (const ide of ideConfigs) {
+        // Write to Cursor always (primary target); write to Claude if dir exists
+        const dirExists = existsSync(join(ide.path, '..'));
+        if (ide.name === 'Cursor' || dirExists) {
+            try {
+                mergeIdeConfig(ide.path, serverConfig);
+                console.log(chalk.green(`  ✓ ${ide.name}`), chalk.dim(ide.path));
+                wroteAny = true;
+            }
+            catch (err) {
+                console.log(chalk.red(`  ✗ ${ide.name}`), chalk.dim(err.message));
+            }
+        }
+    }
+    if (wroteAny) {
+        console.log(chalk.dim('\n  MCP server entries merged into IDE config (existing servers preserved).\n'));
+    }
+    else {
+        console.log(chalk.yellow('\n  No IDE config files found. Printing config for manual setup:\n'));
+        console.log(chalk.green(JSON.stringify({ mcpServers: serverConfig }, null, 2)));
+        console.log();
+    }
+    // ── 4. Generate IDE rules ────────────────────────────────────────────────
+    console.log(chalk.bold('  Generating IDE rules...\n'));
+    await initCommand({ projectRoot: options.projectRoot, staging: options.staging });
+    // ── 5. Claude Code one-liners ────────────────────────────────────────────
+    console.log(chalk.bold('  Claude Code one-liner alternative:\n'));
+    console.log(chalk.dim('  If you prefer `claude mcp add` instead of settings.json:\n'));
+    const coreServers = ['constraints', 'premortem', 'tools', 'exploration'];
+    for (const name of coreServers) {
+        console.log(chalk.cyan(`  claude mcp add cutline-${name} -- npx -y @kylewadegrove/cutline-mcp-cli serve ${name}`));
+    }
+    console.log();
+    // ── 6. What you can do ───────────────────────────────────────────────────
+    console.log(chalk.bold('  Restart your IDE, then ask your AI agent:\n'));
+    if (tier === 'premium') {
+        const items = [
+            { cmd: 'Run a deep dive on my product idea', desc: 'Pre-mortem analysis — risks, assumptions, experiments' },
+            { cmd: 'Run a code audit for my product', desc: 'Security scan + RGR remediation plan' },
+            { cmd: 'Check constraints for src/api/upload.ts', desc: 'Get NFR boundaries for a specific file' },
+            { cmd: 'Generate .cutline.md for my product', desc: 'Write the constraint routing engine' },
+            { cmd: 'What does my persona think about X?', desc: 'AI persona feedback on features' },
+        ];
+        for (const item of items) {
+            console.log(`  ${chalk.cyan('→')} ${chalk.white(`"${item.cmd}"`)}`);
+            console.log(`    ${chalk.dim(item.desc)}`);
+        }
+    }
+    else {
+        const items = [
+            { cmd: 'Run an engineering audit on this codebase', desc: 'Security, reliability, and scalability scan (3/month free)' },
+        ];
+        for (const item of items) {
+            console.log(`  ${chalk.cyan('→')} ${chalk.white(`"${item.cmd}"`)}`);
+            console.log(`    ${chalk.dim(item.desc)}`);
+        }
+        console.log();
+        console.log(chalk.dim('  Upgrade to Premium for deep dives, code audits, constraint graphs, and personas'));
+        console.log(chalk.dim('  →'), chalk.cyan('cutline-mcp upgrade'), chalk.dim('or https://thecutline.ai/upgrade'));
+    }
+    console.log();
+    console.log(chalk.dim(`  cutline-mcp v${version} · docs: https://thecutline.ai/docs/setup`));
+    console.log();
+}

package/dist/commands/status.js

@@ -1,13 +1,7 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.statusCommand = statusCommand;
-const chalk_1 = __importDefault(require("chalk"));
-const ora_1 = __importDefault(require("ora"));
-const keychain_js_1 = require("../auth/keychain.js");
-const config_js_1 = require("../utils/config.js");
+import chalk from 'chalk';
+import ora from 'ora';
+import { getRefreshToken } from '../auth/keychain.js';
+import { fetchFirebaseApiKey } from '../utils/config.js';
 async function getSubscriptionStatus(idToken, isStaging) {
     try {
         const baseUrl = isStaging
@@ -53,26 +47,26 @@ async function exchangeRefreshToken(refreshToken, apiKey) {
     const data = await response.json();
     return data.id_token;
 }
-async function statusCommand(options) {
-    console.log(chalk_1.default.bold('\n📊 Cutline MCP Status\n'));
-    const spinner = (0, ora_1.default)('Checking authentication...').start();
+export async function statusCommand(options) {
+    console.log(chalk.bold('\n📊 Cutline MCP Status\n'));
+    const spinner = ora('Checking authentication...').start();
     try {
         // Check for stored refresh token
-        const refreshToken = await (0, keychain_js_1.getRefreshToken)();
+        const refreshToken = await getRefreshToken();
         if (!refreshToken) {
-            spinner.info(chalk_1.default.yellow('Not authenticated'));
-            console.log(chalk_1.default.gray('  Run'), chalk_1.default.cyan('cutline-mcp login'), chalk_1.default.gray('to authenticate\n'));
+            spinner.info(chalk.yellow('Not authenticated'));
+            console.log(chalk.gray('  Run'), chalk.cyan('cutline-mcp login'), chalk.gray('to authenticate\n'));
             return;
         }
         // Get Firebase API key
         spinner.text = 'Fetching configuration...';
         let firebaseApiKey;
         try {
-            firebaseApiKey = await (0, config_js_1.fetchFirebaseApiKey)(options);
+            firebaseApiKey = await fetchFirebaseApiKey(options);
         }
         catch (error) {
-            spinner.fail(chalk_1.default.red('Configuration error'));
-            console.error(chalk_1.default.red(`  ${error instanceof Error ? error.message : 'Failed to get Firebase API key'}`));
+            spinner.fail(chalk.red('Configuration error'));
+            console.error(chalk.red(`  ${error instanceof Error ? error.message : 'Failed to get Firebase API key'}`));
             process.exit(1);
         }
         // Exchange refresh token for ID token
@@ -81,18 +75,18 @@ async function statusCommand(options) {
         // Decode JWT payload (base64) to get user info - no verification needed, just display
         const payloadBase64 = idToken.split('.')[1];
         const decoded = JSON.parse(Buffer.from(payloadBase64, 'base64').toString());
-        spinner.succeed(chalk_1.default.green('Authenticated'));
-        console.log(chalk_1.default.gray('  User:'), chalk_1.default.white(decoded.email || decoded.user_id || decoded.sub));
-        console.log(chalk_1.default.gray('  UID:'), chalk_1.default.dim(decoded.user_id || decoded.sub));
+        spinner.succeed(chalk.green('Authenticated'));
+        console.log(chalk.gray('  User:'), chalk.white(decoded.email || decoded.user_id || decoded.sub));
+        console.log(chalk.gray('  UID:'), chalk.dim(decoded.user_id || decoded.sub));
         // Calculate token expiry
         const expiresIn = Math.floor((decoded.exp * 1000 - Date.now()) / 1000 / 60);
-        console.log(chalk_1.default.gray('  Token expires in:'), chalk_1.default.white(`${expiresIn} minutes`));
+        console.log(chalk.gray('  Token expires in:'), chalk.white(`${expiresIn} minutes`));
         // Show custom claims if present
         if (decoded.mcp) {
-            console.log(chalk_1.default.gray('  MCP enabled:'), chalk_1.default.green('✓'));
+            console.log(chalk.gray('  MCP enabled:'), chalk.green('✓'));
         }
         if (decoded.deviceId) {
-            console.log(chalk_1.default.gray('  Device ID:'), chalk_1.default.dim(decoded.deviceId));
+            console.log(chalk.gray('  Device ID:'), chalk.dim(decoded.deviceId));
         }
         // Check subscription status via Cloud Function
         spinner.start('Checking subscription...');
@@ -100,33 +94,33 @@ async function statusCommand(options) {
         spinner.stop();
         if (subscription.status === 'active' || subscription.status === 'trialing') {
             const statusLabel = subscription.status === 'trialing' ? ' (trial)' : '';
-            console.log(chalk_1.default.gray('  Plan:'), chalk_1.default.green(`✓ ${subscription.planName || 'Premium'}${statusLabel}`));
+            console.log(chalk.gray('  Plan:'), chalk.green(`✓ ${subscription.planName || 'Premium'}${statusLabel}`));
             if (subscription.periodEnd) {
                 const periodEndDate = new Date(subscription.periodEnd);
                 const daysLeft = Math.ceil((periodEndDate.getTime() - Date.now()) / (1000 * 60 * 60 * 24));
-                console.log(chalk_1.default.gray('  Renews:'), chalk_1.default.white(`${periodEndDate.toLocaleDateString()} (${daysLeft} days)`));
+                console.log(chalk.gray('  Renews:'), chalk.white(`${periodEndDate.toLocaleDateString()} (${daysLeft} days)`));
             }
         }
         else if (subscription.status === 'past_due') {
-            console.log(chalk_1.default.gray('  Plan:'), chalk_1.default.yellow('⚠ Premium (payment past due)'));
+            console.log(chalk.gray('  Plan:'), chalk.yellow('⚠ Premium (payment past due)'));
         }
         else if (subscription.status === 'canceled') {
-            console.log(chalk_1.default.gray('  Plan:'), chalk_1.default.yellow('Premium (canceled)'));
+            console.log(chalk.gray('  Plan:'), chalk.yellow('Premium (canceled)'));
             if (subscription.periodEnd) {
-                console.log(chalk_1.default.gray('  Access until:'), chalk_1.default.white(new Date(subscription.periodEnd).toLocaleDateString()));
+                console.log(chalk.gray('  Access until:'), chalk.white(new Date(subscription.periodEnd).toLocaleDateString()));
             }
         }
         else {
-            console.log(chalk_1.default.gray('  Plan:'), chalk_1.default.white('Free'));
-            console.log(chalk_1.default.dim('  Upgrade at'), chalk_1.default.cyan('https://thecutline.ai/pricing'));
+            console.log(chalk.gray('  Plan:'), chalk.white('Free'));
+            console.log(chalk.dim('  Upgrade at'), chalk.cyan('https://thecutline.ai/pricing'));
         }
         console.log();
     }
     catch (error) {
-        spinner.fail(chalk_1.default.red('Status check failed'));
+        spinner.fail(chalk.red('Status check failed'));
         if (error instanceof Error) {
-            console.error(chalk_1.default.red(`  ${error.message}`));
-            console.log(chalk_1.default.gray('  Try running'), chalk_1.default.cyan('cutline-mcp login'), chalk_1.default.gray('again\n'));
+            console.error(chalk.red(`  ${error.message}`));
+            console.log(chalk.gray('  Try running'), chalk.cyan('cutline-mcp login'), chalk.gray('again\n'));
         }
         process.exit(1);
     }

package/dist/commands/upgrade.js

@@ -1,16 +1,10 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.upgradeCommand = upgradeCommand;
-const open_1 = __importDefault(require("open"));
-const chalk_1 = __importDefault(require("chalk"));
-const ora_1 = __importDefault(require("ora"));
-const callback_js_1 = require("../auth/callback.js");
-const keychain_js_1 = require("../auth/keychain.js");
-const config_store_js_1 = require("../utils/config-store.js");
-const config_js_1 = require("../utils/config.js");
+import open from 'open';
+import chalk from 'chalk';
+import ora from 'ora';
+import { startCallbackServer } from '../auth/callback.js';
+import { storeRefreshToken } from '../auth/keychain.js';
+import { saveConfig } from '../utils/config-store.js';
+import { getConfig, fetchFirebaseApiKey } from '../utils/config.js';
 async function exchangeCustomToken(customToken, apiKey) {
     const response = await fetch(`https://identitytoolkit.googleapis.com/v1/accounts:signInWithCustomToken?key=${apiKey}`, {
         method: 'POST',
@@ -30,35 +24,35 @@ async function exchangeCustomToken(customToken, apiKey) {
         email: data.email,
     };
 }
-async function upgradeCommand(options) {
-    const config = (0, config_js_1.getConfig)(options);
-    console.log(chalk_1.default.bold('\n⬆️  Cutline MCP - Upgrade to Premium\n'));
+export async function upgradeCommand(options) {
+    const config = getConfig(options);
+    console.log(chalk.bold('\n⬆️  Cutline MCP - Upgrade to Premium\n'));
     if (options.staging) {
-        console.log(chalk_1.default.yellow('  ⚠️  Using STAGING environment\n'));
+        console.log(chalk.yellow('  ⚠️  Using STAGING environment\n'));
     }
     // Fetch Firebase API key
     let firebaseApiKey;
     try {
-        firebaseApiKey = await (0, config_js_1.fetchFirebaseApiKey)(options);
+        firebaseApiKey = await fetchFirebaseApiKey(options);
     }
     catch (error) {
-        console.error(chalk_1.default.red(`Error: ${error instanceof Error ? error.message : 'Failed to get Firebase API key'}`));
+        console.error(chalk.red(`Error: ${error instanceof Error ? error.message : 'Failed to get Firebase API key'}`));
         process.exit(1);
     }
     // Determine upgrade URL based on environment
     const baseUrl = options.staging
         ? 'https://cutline-staging.web.app'
         : 'https://thecutline.ai';
-    console.log(chalk_1.default.gray('  Opening upgrade page in your browser...\n'));
-    console.log(chalk_1.default.dim('  After upgrading, your MCP session will be refreshed automatically.\n'));
-    const spinner = (0, ora_1.default)('Waiting for upgrade and re-authentication...').start();
+    console.log(chalk.gray('  Opening upgrade page in your browser...\n'));
+    console.log(chalk.dim('  After upgrading, your MCP session will be refreshed automatically.\n'));
+    const spinner = ora('Waiting for upgrade and re-authentication...').start();
     try {
         // Start callback server for re-auth after upgrade
-        const serverPromise = (0, callback_js_1.startCallbackServer)();
+        const serverPromise = startCallbackServer();
         // Open upgrade page with callback for re-auth
         // The upgrade page will redirect to mcp-auth after successful upgrade
         const upgradeUrl = `${baseUrl}/upgrade?mcp_callback=${encodeURIComponent(config.CALLBACK_URL)}`;
-        await (0, open_1.default)(upgradeUrl);
+        await open(upgradeUrl);
         spinner.text = 'Browser opened - complete your upgrade, then re-authenticate';
         // Wait for callback with new token (after upgrade + re-auth)
         const result = await serverPromise;
@@ -67,37 +61,49 @@ async function upgradeCommand(options) {
         const { refreshToken, email } = await exchangeCustomToken(result.token, firebaseApiKey);
         // Store refresh token
         try {
-            await (0, keychain_js_1.storeRefreshToken)(refreshToken);
+            await storeRefreshToken(refreshToken);
         }
         catch (error) {
-            console.warn(chalk_1.default.yellow('  ⚠️  Could not save to Keychain (skipping)'));
+            console.warn(chalk.yellow('  ⚠️  Could not save to Keychain (skipping)'));
         }
         // Save to file config (API key is fetched at runtime, not stored)
         try {
-            (0, config_store_js_1.saveConfig)({
+            saveConfig({
                 refreshToken,
                 environment: options.staging ? 'staging' : 'production',
             });
         }
         catch (error) {
-            console.error(chalk_1.default.red('  ✗ Failed to save config file:'), error);
+            console.error(chalk.red('  ✗ Failed to save config file:'), error);
         }
-        spinner.succeed(chalk_1.default.green('Upgrade complete! Session refreshed.'));
-        const envLabel = options.staging ? chalk_1.default.yellow('STAGING') : chalk_1.default.green('PRODUCTION');
-        console.log(chalk_1.default.gray(`  Environment: ${envLabel}`));
+        spinner.succeed(chalk.green('Upgrade complete! Session refreshed.'));
+        const envLabel = options.staging ? chalk.yellow('STAGING') : chalk.green('PRODUCTION');
+        console.log(chalk.gray(`  Environment: ${envLabel}`));
         if (email || result.email) {
-            console.log(chalk_1.default.gray(`  Account: ${email || result.email}`));
+            console.log(chalk.gray(`  Account: ${email || result.email}`));
         }
-        console.log(chalk_1.default.green('\n  ✨ Premium features are now available!\n'));
-        console.log(chalk_1.default.dim('  Try:'), chalk_1.default.cyan('exploration_graduate'), chalk_1.default.dim('to run a full Deep Dive\n'));
+        console.log(chalk.green('\n  Premium features are now available!\n'));
+        console.log(chalk.bold('  Re-run init to update your IDE rules:'));
+        console.log(chalk.cyan('    cutline-mcp init\n'));
+        console.log(chalk.bold('  Then ask your AI agent:\n'));
+        const items = [
+            { cmd: 'Run a deep dive on my product idea', desc: 'Pre-mortem analysis — risks, assumptions, experiments' },
+            { cmd: 'Run a code audit for my product', desc: 'Security scan + RGR remediation plan' },
+            { cmd: 'Generate .cutline.md for my product', desc: 'Write the constraint routing engine' },
+        ];
+        for (const item of items) {
+            console.log(`  ${chalk.cyan('→')} ${chalk.white(`"${item.cmd}"`)}`);
+            console.log(`    ${chalk.dim(item.desc)}`);
+        }
+        console.log();
     }
     catch (error) {
-        spinner.fail(chalk_1.default.red('Upgrade flow failed'));
+        spinner.fail(chalk.red('Upgrade flow failed'));
         if (error instanceof Error) {
-            console.error(chalk_1.default.red(`  ${error.message}`));
+            console.error(chalk.red(`  ${error.message}`));
         }
-        console.log(chalk_1.default.gray('\n  You can also upgrade at:'), chalk_1.default.cyan(`${baseUrl}/upgrade`));
-        console.log(chalk_1.default.gray('  Then run:'), chalk_1.default.cyan('cutline-mcp login'), chalk_1.default.gray('to refresh your session\n'));
+        console.log(chalk.gray('\n  You can also upgrade at:'), chalk.cyan(`${baseUrl}/upgrade`));
+        console.log(chalk.gray('  Then run:'), chalk.cyan('cutline-mcp login'), chalk.gray('to refresh your session\n'));
         process.exit(1);
     }
 }

package/dist/index.js

@@ -1,35 +1,59 @@
 #!/usr/bin/env node
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const commander_1 = require("commander");
-const login_js_1 = require("./commands/login.js");
-const logout_js_1 = require("./commands/logout.js");
-const status_js_1 = require("./commands/status.js");
-const upgrade_js_1 = require("./commands/upgrade.js");
-const program = new commander_1.Command();
+import { Command } from 'commander';
+import { readFileSync } from 'fs';
+import { fileURLToPath } from 'url';
+import { dirname, join } from 'path';
+import { loginCommand } from './commands/login.js';
+import { logoutCommand } from './commands/logout.js';
+import { statusCommand } from './commands/status.js';
+import { upgradeCommand } from './commands/upgrade.js';
+import { serveCommand } from './commands/serve.js';
+import { setupCommand } from './commands/setup.js';
+import { initCommand } from './commands/init.js';
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+const pkg = JSON.parse(readFileSync(join(__dirname, '..', 'package.json'), 'utf-8'));
+const program = new Command();
 program
     .name('cutline-mcp')
-    .description('CLI tool for authenticating with Cutline MCP servers')
-    .version('0.1.0');
+    .description('CLI and MCP servers for Cutline')
+    .version(pkg.version);
 program
     .command('login')
     .description('Authenticate with Cutline and store credentials')
     .option('--staging', 'Use staging environment')
     .option('--signup', 'Open sign-up page instead of sign-in')
     .option('--email <address>', 'Request sign-in with specific email address')
-    .action(login_js_1.loginCommand);
+    .action(loginCommand);
 program
     .command('logout')
     .description('Remove stored credentials')
-    .action(logout_js_1.logoutCommand);
+    .action(logoutCommand);
 program
     .command('status')
     .description('Show current authentication status')
     .option('--staging', 'Use staging environment')
-    .action(status_js_1.statusCommand);
+    .action(statusCommand);
 program
     .command('upgrade')
     .description('Upgrade to Premium and refresh your session')
     .option('--staging', 'Use staging environment')
-    .action(upgrade_js_1.upgradeCommand);
+    .action(upgradeCommand);
+program
+    .command('serve <server>')
+    .description('Start an MCP server (constraints, premortem, exploration, tools, output, integrations)')
+    .action(serveCommand);
+program
+    .command('setup')
+    .description('One-command onboarding: authenticate, write IDE MCP config, generate rules')
+    .option('--staging', 'Use staging environment')
+    .option('--skip-login', 'Skip authentication (use existing credentials)')
+    .option('--project-root <path>', 'Project root directory for IDE rules (default: cwd)')
+    .action((opts) => setupCommand({ staging: opts.staging, skipLogin: opts.skipLogin, projectRoot: opts.projectRoot }));
+program
+    .command('init')
+    .description('Generate IDE rules only (setup runs this automatically)')
+    .option('--project-root <path>', 'Project root directory (default: cwd)')
+    .option('--staging', 'Use staging environment')
+    .action((opts) => initCommand({ projectRoot: opts.projectRoot, staging: opts.staging }));
 program.parse();