@vibekiln/cutline-mcp-cli 0.12.0 → 0.14.0

package/README.md

@@ -14,6 +14,16 @@
 npm install -g @vibekiln/cutline-mcp-cli@latest
 ```
 
+`@vibekiln/cutline-mcp-cli` includes the standard Cutline MCP servers and **SlopBurn** (the product quality engineering roguelike RPG mode) in the same install.
+
+If you want a dedicated SlopBurn-first CLI with separate onboarding/config UX, use:
+
+```bash
+npm install -g @vibekiln/slopburn-cli
+slopburn setup
+slopburn serve
+```
+
 ### Docker
 
 ```bash
@@ -62,6 +72,11 @@ Cutline interprets intent and tier:
 | **AI Personas** — stakeholder feedback on features | — | Full access |
 | **Idea Validation** — fast-track from free web validation | — | Included |
 
+### SlopBurn
+
+SlopBurn is a **product quality engineering roguelike RPG** built into the Cutline MCP ecosystem.
+It turns deep-dive + verification loops into game progression, where test checks act like encounters, XP tracks quality gains, and MCP servers unlock as spells.
+
 ## 54 MCP Tools
 
 ### Free Tier

package/dist/auth/callback.d.ts

@@ -2,5 +2,5 @@ export interface CallbackResult {
     token: string;
     email?: string;
 }
-export type CallbackSource = 'login' | 'setup' | 'upgrade';
+export type CallbackSource = 'login' | 'setup' | 'upgrade' | 'slopburn';
 export declare function startCallbackServer(source?: CallbackSource): Promise<CallbackResult>;

package/dist/auth/callback.js

@@ -59,12 +59,20 @@ export async function startCallbackServer(source = 'login') {
               <div class="checkmark">&#10003;</div>
               <h1>You're in!</h1>
               ${email ? `<p class="email">${email}</p>` : ''}
-              ${source === 'login' ? `
+              ${(source === 'login' || source === 'slopburn') ? `
               <div class="steps">
                 <h3>Next in your terminal</h3>
+                ${source === 'slopburn'
+                ? `
+                <div class="step"><span class="num">1</span><span>Run <code>slopburn setup --staging</code> to install SlopBurn MCP config</span></div>
+                <div class="step"><span class="num">2</span><span>Run <code>slopburn serve --staging</code> to start the SlopBurn server</span></div>
+                <div class="step"><span class="num">3</span><span>Tell your agent: <em>"start slopburn and create my first run"</em></span></div>
+                    `
+                : `
                 <div class="step"><span class="num">1</span><span>Run <code>cutline-mcp init</code> to generate IDE rules</span></div>
                 <div class="step"><span class="num">2</span><span>Run <code>cutline-mcp setup</code> to connect MCP servers</span></div>
                 <div class="step"><span class="num">3</span><span>Ask your agent: <em>"Run an engineering audit"</em></span></div>
+                    `}
               </div>` : `
               <div class="steps">
                 <h3>Go back to your terminal</h3>

package/dist/commands/login.js

@@ -91,7 +91,10 @@ export async function loginCommand(options) {
         }
         // Start callback server
         spinner.text = 'Waiting for authentication...';
-        const serverPromise = startCallbackServer(options.source ?? 'login');
+        const envSource = process.env.CUTLINE_MCP_AUTH_SOURCE;
+        const validSource = (value) => value === 'login' || value === 'setup' || value === 'upgrade' || value === 'slopburn';
+        const callbackSource = options.source ?? (validSource(envSource) ? envSource : 'login');
+        const serverPromise = startCallbackServer(callbackSource);
         // Open browser — default is the quick email-only flow
         let authUrl = `${config.AUTH_URL}?callback=${encodeURIComponent(config.CALLBACK_URL)}`;
         if (options.signup) {

package/dist/commands/serve.d.ts

@@ -1,8 +1,12 @@
+export declare const SERVER_MAP: Record<string, string>;
 interface ServeOptions {
     http?: boolean;
     host?: string;
     port?: string;
     path?: string;
+    staging?: boolean;
 }
+export declare function resolveServerFileName(serverName: string): string | null;
+export declare function resolveServerBundlePath(serverName: string, baseDir?: string): string | null;
 export declare function serveCommand(serverName: string, options?: ServeOptions): void;
 export {};

package/dist/commands/serve.js

@@ -4,14 +4,22 @@ import { resolve, dirname } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { existsSync } from 'node:fs';
 const __dirname = dirname(fileURLToPath(import.meta.url));
-const SERVER_MAP = {
+export const SERVER_MAP = {
     constraints: 'cutline-server.js',
     premortem: 'premortem-server.js',
     exploration: 'exploration-server.js',
     tools: 'tools-server.js',
     output: 'output-server.js',
     integrations: 'integrations-server.js',
+    slopburn: 'slopburn-server.js',
 };
+export function resolveServerFileName(serverName) {
+    return SERVER_MAP[serverName] ?? null;
+}
+export function resolveServerBundlePath(serverName, baseDir = __dirname) {
+    const fileName = resolveServerFileName(serverName);
+    return fileName ? resolve(baseDir, '../servers', fileName) : null;
+}
 function handleChildMessage(message, pending) {
     const parsed = message;
     const id = normalizeId(parsed?.id);
@@ -72,9 +80,12 @@ function serveHttpBridge(serverName, serverPath, opts) {
         console.error(`Invalid --port value: ${opts.port}`);
         process.exit(1);
     }
+    const childEnv = opts.staging
+        ? { ...process.env, CUTLINE_ENV: 'staging' }
+        : process.env;
     const child = spawn(process.execPath, [serverPath], {
         stdio: ['pipe', 'pipe', 'inherit'],
-        env: process.env,
+        env: childEnv,
     });
     const pending = new Map();
     let stdoutBuffer = Buffer.alloc(0);
@@ -216,18 +227,20 @@ function serveHttpBridge(serverName, serverPath, opts) {
     });
 }
 export function serveCommand(serverName, options = {}) {
-    const fileName = SERVER_MAP[serverName];
-    if (!fileName) {
+    const serverPath = resolveServerBundlePath(serverName);
+    if (!serverPath) {
         const valid = Object.keys(SERVER_MAP).join(', ');
         console.error(`Unknown server: "${serverName}". Valid names: ${valid}`);
         process.exit(1);
     }
-    const serverPath = resolve(__dirname, '../servers', fileName);
     if (!existsSync(serverPath)) {
         console.error(`Server bundle not found at ${serverPath}`);
         console.error('The package may not have been built correctly.');
         process.exit(1);
     }
+    const childEnv = options.staging
+        ? { ...process.env, CUTLINE_ENV: 'staging' }
+        : process.env;
     if (options.http) {
         serveHttpBridge(serverName, serverPath, options);
         return;
@@ -236,7 +249,7 @@ export function serveCommand(serverName, options = {}) {
     try {
         execFileSync(process.execPath, [serverPath], {
             stdio: 'inherit',
-            env: process.env,
+            env: childEnv,
         });
     }
     catch (err) {

package/dist/commands/setup.js

@@ -27,6 +27,7 @@ const SERVER_NAMES = [
     'tools',
     'output',
     'integrations',
+    'slopburn',
 ];
 const AUDIT_DIMENSIONS = ['engineering', 'security', 'reliability', 'scalability', 'compliance'];
 async function detectTier(options) {
@@ -173,12 +174,13 @@ function resolveServeRuntime() {
         source: 'npx',
     };
 }
-function buildServerConfig(runtime) {
+function buildServerConfig(runtime, options) {
     const config = {};
+    const envArgs = options?.staging ? ['--staging'] : [];
     for (const name of SERVER_NAMES) {
         config[`cutline-${name}`] = {
             command: runtime.command,
-            args: [...runtime.argsPrefix, 'serve', name],
+            args: [...runtime.argsPrefix, 'serve', name, ...envArgs],
         };
     }
     return config;
@@ -339,7 +341,7 @@ export async function setupCommand(options) {
     }
     // ── 3. Write MCP server config to IDEs ───────────────────────────────────
     const runtime = resolveServeRuntime();
-    const serverConfig = buildServerConfig(runtime);
+    const serverConfig = buildServerConfig(runtime, { staging: options.staging });
     const home = homedir();
     const ideConfigs = [
         { name: 'Cursor', path: join(home, '.cursor', 'mcp.json') },
@@ -443,8 +445,9 @@ export async function setupCommand(options) {
     console.log(chalk.bold('  Claude Code one-liner alternative:\n'));
     console.log(chalk.dim('  If you prefer `claude mcp add` instead of ~/.claude.json:\n'));
     const coreServers = ['constraints', 'premortem', 'tools', 'exploration'];
+    const stagingArg = options.staging ? ' --staging' : '';
     for (const name of coreServers) {
-        const invocation = [runtime.command, ...runtime.argsPrefix, 'serve', name].join(' ');
+        const invocation = [runtime.command, ...runtime.argsPrefix, 'serve', name].join(' ') + stagingArg;
         console.log(chalk.cyan(`  claude mcp add cutline-${name} -- ${invocation}`));
     }
     console.log();

package/dist/index.js

@@ -17,7 +17,7 @@ const pkg = JSON.parse(readFileSync(join(__dirname, '..', 'package.json'), 'utf-
 const program = new Command();
 program
     .name('cutline-mcp')
-    .description('CLI and MCP servers for Cutline')
+    .description('CLI and MCP servers for Cutline, including SlopBurn (a product quality engineering roguelike RPG)')
     .version(pkg.version);
 program
     .command('login')
@@ -47,7 +47,8 @@ program
     .action(upgradeCommand);
 program
     .command('serve <server>')
-    .description('Start an MCP server (constraints, premortem, exploration, tools, output, integrations)')
+    .description('Start an MCP server (constraints, premortem, exploration, tools, output, integrations, slopburn)')
+    .option('--staging', 'Use staging environment')
     .option('--http', 'Expose the selected stdio server over an HTTP bridge')
     .option('--host <host>', 'HTTP bind host for bridge mode (default: 0.0.0.0)')
     .option('--port <port>', 'HTTP port for bridge mode (default: 8080)')
@@ -57,6 +58,7 @@ program
     host: opts.host,
     port: opts.port,
     path: opts.path,
+    staging: opts.staging,
 }));
 program
     .command('setup')