@vibekiln/slopburn-cli-staging 0.1.0

package/README.md

@@ -0,0 +1,91 @@
+# SlopBurn CLI
+
+`slopburn` is a first-class CLI for SlopBurn with dedicated onboarding and MCP config, while reusing Cutline's auth/runtime components under the hood.
+
+## Install
+
+```bash
+npm i -g @vibekiln/slopburn-cli
+```
+
+For staging:
+
+```bash
+npm i -g @vibekiln/slopburn-cli-staging
+```
+
+## Commands
+
+- `slopburn setup [--staging] [--serve-now]`  
+  Writes MCP config entries for only the `slopburn` server, saves channel preference in `~/.slopburn/config.json`, writes project-local game defaults to `.cutline/slopburn.json`, and installs `.cursor/rules/slopburn-intents.mdc` so natural-language prompts route to SlopBurn MCP tools.
+  - `--serve-now` launches the MCP server immediately after setup to reduce handoff friction.
+  - `--verbose` prints the longer setup summary.
+- `slopburn login [--staging]`
+- `slopburn status [--staging]`
+- `slopburn logout [--staging]`
+- `slopburn serve [--staging] [--project-root <path>] [--http --host --port --path] [--verbose]`
+- `slopburn bootstrap [--project-root <path>] [--full]`
+- `slopburn event <title|level-up|game-over|encounter|victory>` (renders local terminal banners/audio cues)
+
+## How it works
+
+- `setup` writes `slopburn` MCP entries separately from `cutline-*` entries.
+- Generated MCP config calls `slopburn serve` directly instead of wrapping startup in `npx`.
+- `serve` delegates to Cutline MCP components via:
+  - production: `@vibekiln/cutline-mcp-cli`
+  - staging: `@vibekiln/cutline-mcp-cli-staging`
+- `slopburn` now bundles both Cutline CLI packages as dependencies, so one global install is enough.
+- Runtime prefers the bundled local dependency and only falls back to `npx` resolution if needed.
+
+This keeps SlopBurn onboarding/config independent while still leveraging shared Cutline internals.
+
+## Startup Model
+
+- `~/.slopburn/config.json` stores machine-local CLI state like the preferred channel.
+- `.cutline/slopburn.json` stores project-local game defaults such as:
+  - onboarding mode
+  - default character name/class
+  - optional project/product linkage
+  - quiet/auto-resume startup preferences
+- MCP startup reads the project-local config, so the same defaults work whether SlopBurn is launched from `slopburn serve` or from your IDE MCP config.
+
+## First-Time Setup
+
+```bash
+slopburn setup --serve-now
+```
+
+Then refresh your MCP/chat session and say:
+
+```text
+start slopburn
+```
+
+If you want the longer reference output, run:
+
+```bash
+slopburn bootstrap --full
+```
+
+## Returning User
+
+If `.cutline/slopburn.json` already exists, setup reuses it and avoids repeating character questions:
+
+```bash
+slopburn setup --serve-now
+```
+
+Then refresh your MCP/chat session and say:
+
+```text
+start slopburn
+```
+
+## Natural-language start prompts
+
+After `slopburn setup`, you can say these directly in your AI chat:
+
+- `start slopburn`
+- `take a turn in slopburn for this feature idea`
+- `roll tests as the dungeon check for my run`
+- `show my spellbook and equip the best offered spell`

package/dist/ascii.d.ts

@@ -0,0 +1,6 @@
+export declare const SLOPBURN_ASCII: {
+    readonly title: string;
+    readonly install: string;
+    readonly levelUp: string;
+    readonly gameOver: string;
+};

package/dist/ascii.js

@@ -0,0 +1,33 @@
+export const SLOPBURN_ASCII = {
+    title: String.raw `
+ .d8888b.  888       .d88888b.  8888888b.  888888b.   888     888 8888888b.  888b    888
+d88P  Y88b 888      d88P" "Y88b 888   Y88b 888  "88b  888     888 888   Y88b 8888b   888
+Y88b.      888      888     888 888    888 888  .88P  888     888 888    888 88888b  888
+ "Y888b.   888      888     888 888   d88P 8888888K.  888     888 888   d88P 888Y88b 888
+    "Y88b. 888      888     888 8888888P"  888  "Y88b 888     888 8888888P"  888 Y88b888
+      "888 888      888     888 888        888    888 888     888 888 T88b   888  Y88888
+Y88b  d88P 888      Y88b. .d88P 888        888   d88P Y88b. .d88P 888  T88b  888   Y8888
+ "Y8888P"  88888888  "Y88888P"  888        8888888P"   "Y88888P"  888   T88b 888    Y888
+`,
+    install: String.raw `
+ ____  _      ___  ____  ____  _   _ ____  _   _
+/ ___|| |    / _ \|  _ \| __ )| | | |  _ \| \ | |
+\___ \| |   | | | | |_) |  _ \| | | | |_) |  \| |
+ ___) | |___| |_| |  __/| |_) | |_| |  _ <| |\  |
+|____/|_____|\___/|_|   |____/ \___/|_| \_\_| \_|
+`,
+    levelUp: String.raw `
+ _                    _   _   _ ____  
+| |    _____   _____| | | | | |  _ \ 
+| |   / _ \ \ / / _ \ | | | | | |_) |
+| |__|  __/\ V /  __/ | | |_| |  __/ 
+|_____\___| \_/ \___|_|  \___/|_|    
+`,
+    gameOver: String.raw `
+  ____                         ___                 
+ / ___| __ _ _ __ ___   ___   / _ \__   _____ _ __ 
+| |  _ / _\` | '_ \` _ \ / _ \ | | | \ \ / / _ \ '__|
+| |_| | (_| | | | | | |  __/ | |_| |\ V /  __/ |   
+ \____|\__,_|_| |_| |_|\___|  \___/  \_/ \___|_|   
+`,
+};

package/dist/commands/bootstrap.d.ts

@@ -0,0 +1,6 @@
+interface BootstrapOptions {
+    projectRoot?: string;
+    full?: boolean;
+}
+export declare function bootstrapCommand(options: BootstrapOptions): void;
+export {};

package/dist/commands/bootstrap.js

@@ -0,0 +1,53 @@
+import chalk from "chalk";
+import { resolve } from "node:path";
+import { getProjectGameConfigPath, readProjectGameConfig, resolveSavedOnboarding } from "../utils/config.js";
+function buildPrimaryPrompt(onboarding) {
+    return "start slopburn";
+}
+export function bootstrapCommand(options) {
+    const projectRoot = resolve(String(options.projectRoot || process.cwd()));
+    const configPath = getProjectGameConfigPath(projectRoot);
+    const projectConfig = readProjectGameConfig(projectRoot);
+    const onboarding = resolveSavedOnboarding(projectRoot);
+    const hasConfiguredCharacter = Boolean(onboarding?.characterName && onboarding?.characterClass);
+    const primaryPrompt = buildPrimaryPrompt(onboarding);
+    console.log(chalk.bold("\nSlopBurn Bootstrap\n"));
+    console.log(chalk.green("  ✓"), chalk.dim(`Game config: ${configPath}`));
+    if (onboarding?.mode === "new_character" && hasConfiguredCharacter) {
+        console.log(chalk.green("  ✓"), chalk.dim(`Saved character: ${onboarding.characterName} (${onboarding.characterClass})`));
+    }
+    else if (onboarding?.mode === "existing_project") {
+        console.log(chalk.green("  ✓"), chalk.dim(`Saved mode: existing project${onboarding.productId ? ` (${onboarding.productId})` : ""}`));
+    }
+    else {
+        console.log(chalk.yellow("  !"), chalk.dim("No saved character defaults found; setup will fall back to interactive onboarding."));
+    }
+    console.log(chalk.dim(`  In chat: "${primaryPrompt}"`));
+    console.log(chalk.dim(`  Startup mode: ${projectConfig.startup?.autoResume === false ? "manual" : "auto-resume ready"}\n`));
+    if (!options.full) {
+        console.log(chalk.dim("  MCP path: slopburn_start_run -> slopburn_prepare_battle -> slopburn_roll_tests\n"));
+        return;
+    }
+    console.log(chalk.dim("Run these MCP tools from your AI client (not in shell):\n"));
+    console.log(chalk.cyan("1) slopburn_start_run"));
+    console.log(chalk.dim("   Canonical fast-start. Uses .cutline/slopburn.json defaults and auto-opens the first dungeon battle when possible"));
+    console.log();
+    console.log(chalk.cyan("2) slopburn_bootstrap_run"));
+    console.log(chalk.dim("   Only needed if Character Creation or onboarding still needs explicit input"));
+    console.log();
+    console.log(chalk.cyan("3) slopburn_prepare_battle"));
+    console.log(chalk.dim("   Optional if you want to change rooms/phases before the first roll"));
+    console.log();
+    console.log(chalk.cyan("4) slopburn_roll_tests"));
+    console.log(chalk.dim("   Roll verification tests for the prepared mission and start damaging monsters"));
+    console.log();
+    console.log(chalk.cyan("5) slopburn_take_turn / slopburn_status"));
+    console.log(chalk.dim("   Use these after the first fight for deep-dive story progression and async polling"));
+    console.log();
+    console.log(chalk.bold("Suggested prompts:"));
+    console.log(chalk.cyan(` - "${primaryPrompt}"`));
+    console.log(chalk.cyan(' - "take a turn in slopburn"'));
+    console.log(chalk.cyan(' - "roll tests as the dungeon check for my run"'));
+    console.log(chalk.cyan(' - "show my spellbook and equip the best offered spell"'));
+    console.log();
+}

package/dist/commands/event.d.ts

@@ -0,0 +1,5 @@
+interface EventOptions {
+    projectRoot?: string;
+}
+export declare function eventCommand(type: string, options?: EventOptions): Promise<void>;
+export {};

package/dist/commands/event.js

@@ -0,0 +1,92 @@
+import chalk from "chalk";
+import { spawn } from "node:child_process";
+import { access } from "node:fs/promises";
+import { resolve } from "node:path";
+import { SLOPBURN_ASCII } from "../ascii.js";
+import { readProjectGameConfig } from "../utils/config.js";
+async function fileExists(filePath) {
+    try {
+        await access(filePath);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+async function maybePlayConfiguredAudioCue(type, projectRoot) {
+    if (process.platform !== "darwin") {
+        return false;
+    }
+    const projectConfig = readProjectGameConfig(projectRoot);
+    const audio = projectConfig.audio;
+    if (!audio?.enabled) {
+        return false;
+    }
+    const playerCommand = String(audio.playerCommand || "afplay").trim();
+    const configuredSound = type === "encounter"
+        ? String(audio.encounterSound || "/System/Library/Sounds/Sosumi.aiff").trim()
+        : type === "victory"
+            ? String(audio.victorySound || "/System/Library/Sounds/Hero.aiff").trim()
+            : String(audio.titleSound || "/System/Library/Sounds/Submarine.aiff").trim();
+    if (!playerCommand || !configuredSound) {
+        return false;
+    }
+    const soundPath = configuredSound.startsWith("/") ? configuredSound : resolve(projectRoot, configuredSound);
+    if (!(await fileExists(soundPath))) {
+        return false;
+    }
+    try {
+        const child = spawn(playerCommand, [soundPath], {
+            stdio: "ignore",
+            detached: true,
+        });
+        child.on("error", () => { });
+        child.unref();
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export async function eventCommand(type, options = {}) {
+    const normalized = String(type || "").trim().toLowerCase();
+    const projectRoot = resolve(String(options.projectRoot || process.cwd()));
+    if (normalized === "title" || normalized === "intro" || normalized === "theme") {
+        const played = await maybePlayConfiguredAudioCue("title", projectRoot);
+        console.log(chalk.cyan(SLOPBURN_ASCII.title));
+        console.log(chalk.bold("SlopBurn"));
+        console.log(chalk.dim(played ? "Title theme triggered via terminal audio." : "Title theme not played. Check terminal audio setup in .cutline/slopburn.json."));
+        console.log();
+        return;
+    }
+    if (normalized === "level-up" || normalized === "levelup") {
+        console.log(chalk.green(SLOPBURN_ASCII.levelUp));
+        console.log(chalk.bold("Level Up!"));
+        console.log(chalk.dim("You gained power. Pick a perk and review spell offers."));
+        console.log();
+        return;
+    }
+    if (normalized === "game-over" || normalized === "gameover") {
+        console.log(chalk.red(SLOPBURN_ASCII.gameOver));
+        console.log(chalk.bold("Game Over"));
+        console.log(chalk.dim("Commit your checkpoint and take a short break."));
+        console.log();
+        return;
+    }
+    if (normalized === "encounter" || normalized === "monster-encounter" || normalized === "monster_encounter") {
+        const played = await maybePlayConfiguredAudioCue("encounter", projectRoot);
+        console.log(chalk.magenta.bold("Monster Encounter"));
+        console.log(chalk.dim(played ? "Encounter cue triggered via terminal audio." : "Encounter cue not played. Check terminal audio setup in .cutline/slopburn.json."));
+        console.log();
+        return;
+    }
+    if (normalized === "victory" || normalized === "monster-victory" || normalized === "monster_victory") {
+        const played = await maybePlayConfiguredAudioCue("victory", projectRoot);
+        console.log(chalk.green.bold("Monster Defeated"));
+        console.log(chalk.dim(played ? "Victory cue triggered via terminal audio." : "Victory cue not played. Check terminal audio setup in .cutline/slopburn.json."));
+        console.log();
+        return;
+    }
+    console.log(chalk.yellow(`Unknown event "${type}". Use "title", "level-up", "game-over", "encounter", or "victory".`));
+    process.exit(1);
+}

package/dist/commands/setup.d.ts

@@ -0,0 +1,10 @@
+interface SetupOptions {
+    staging?: boolean;
+    projectRoot?: string;
+    testWorkingDirectory?: string;
+    testCommand?: string;
+    serveNow?: boolean;
+    verbose?: boolean;
+}
+export declare function setupCommand(options: SetupOptions): Promise<void>;
+export {};

package/dist/commands/setup.js

@@ -0,0 +1,511 @@
+import chalk from "chalk";
+import { existsSync, mkdirSync, readdirSync, readFileSync, statSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join, resolve } from "node:path";
+import { createInterface } from "node:readline/promises";
+import { runCutlineCliWithEnv } from "../utils/runtime.js";
+import { ensureSlopburnProjectGitignore, getProjectGameConfigPath, readProjectGameConfig, resolveSavedOnboarding, writeProjectGameConfig, writeSlopburnConfig, } from "../utils/config.js";
+const CLASS_OPTIONS = [
+    { id: "fighter", label: "Fighter (balanced damage + resilience)" },
+    { id: "wizard", label: "Wizard (high wisdom, strategic control)" },
+    { id: "rogue", label: "Rogue (high agility, precision strikes)" },
+    { id: "paladin", label: "Paladin (defensive and reliable tank)" },
+];
+function detectCutlineProject(projectRoot) {
+    const configPath = join(projectRoot, ".cutline", "config.json");
+    if (!existsSync(configPath))
+        return {};
+    try {
+        const parsed = JSON.parse(readFileSync(configPath, "utf-8"));
+        return {
+            productId: typeof parsed.product_id === "string" ? parsed.product_id : undefined,
+            projectName: typeof parsed.product_name === "string" ? parsed.product_name : undefined,
+        };
+    }
+    catch {
+        return {};
+    }
+}
+function buildServerConfig(channel, projectRoot) {
+    return {
+        slopburn: {
+            command: "slopburn",
+            args: [
+                "serve",
+                ...(channel === "staging" ? ["--staging"] : []),
+                "--project-root",
+                projectRoot,
+            ],
+        },
+    };
+}
+function buildCanonicalPrompt(_selection) {
+    return "start slopburn";
+}
+function readPackageScripts(packageRoot) {
+    const packagePath = join(packageRoot, "package.json");
+    if (!existsSync(packagePath))
+        return null;
+    try {
+        const parsed = JSON.parse(readFileSync(packagePath, "utf-8"));
+        const scripts = parsed.scripts;
+        return scripts && typeof scripts === "object" ? scripts : {};
+    }
+    catch {
+        return null;
+    }
+}
+function extractScriptNameFromCommand(command) {
+    const normalized = String(command || "").trim();
+    if (!normalized)
+        return null;
+    const npmRunMatch = normalized.match(/(?:^|\s)npm\s+run\s+([^\s]+)/);
+    if (npmRunMatch?.[1])
+        return npmRunMatch[1];
+    const pnpmRunMatch = normalized.match(/(?:^|\s)pnpm\s+run\s+([^\s]+)/);
+    if (pnpmRunMatch?.[1])
+        return pnpmRunMatch[1];
+    const yarnRunMatch = normalized.match(/(?:^|\s)yarn(?:\s+run)?\s+([^\s]+)/);
+    if (yarnRunMatch?.[1])
+        return yarnRunMatch[1];
+    return null;
+}
+function listPackageCandidateDirectories(projectRoot) {
+    const preferred = ["app"];
+    let entries = [];
+    try {
+        entries = readdirSync(projectRoot, { withFileTypes: true });
+    }
+    catch {
+        return [];
+    }
+    const directories = entries
+        .filter((entry) => entry.isDirectory() && !entry.name.startsWith("."))
+        .map((entry) => entry.name);
+    const ordered = [
+        ...preferred.filter((name) => directories.includes(name)),
+        ...directories.filter((name) => !preferred.includes(name)),
+    ];
+    return ordered.map((name) => join(projectRoot, name));
+}
+function normalizeRelativeDirectory(projectRoot, targetDirectory) {
+    const resolvedProjectRoot = resolve(projectRoot);
+    const resolvedTarget = resolve(projectRoot, targetDirectory);
+    if (resolvedTarget === resolvedProjectRoot)
+        return ".";
+    if (!resolvedTarget.startsWith(`${resolvedProjectRoot}/`)) {
+        return targetDirectory;
+    }
+    return resolvedTarget.slice(resolvedProjectRoot.length + 1);
+}
+function detectVerificationConfig(projectRoot, options, existingProjectConfig) {
+    const existingVerification = existingProjectConfig.verification;
+    const explicitCommand = String(options.testCommand || "").trim();
+    const explicitWorkingDirectory = String(options.testWorkingDirectory || "").trim();
+    const command = explicitCommand || existingVerification?.testCommand || "npm run test:unit -- --reporter=json";
+    if (explicitWorkingDirectory) {
+        return {
+            testWorkingDirectory: normalizeRelativeDirectory(projectRoot, explicitWorkingDirectory),
+            testCommand: command,
+            detectionSource: "explicit_flag",
+        };
+    }
+    if (!explicitCommand && existingVerification?.testWorkingDirectory && existingVerification?.testCommand) {
+        return {
+            testWorkingDirectory: existingVerification.testWorkingDirectory,
+            testCommand: existingVerification.testCommand,
+            detectionSource: "existing_config",
+        };
+    }
+    const scriptName = extractScriptNameFromCommand(command);
+    const rootScripts = readPackageScripts(projectRoot);
+    if (scriptName && rootScripts?.[scriptName]) {
+        return {
+            testWorkingDirectory: ".",
+            testCommand: command,
+            detectionSource: "workspace_root",
+        };
+    }
+    if (scriptName) {
+        for (const candidate of listPackageCandidateDirectories(projectRoot)) {
+            const scripts = readPackageScripts(candidate);
+            if (scripts?.[scriptName]) {
+                return {
+                    testWorkingDirectory: normalizeRelativeDirectory(projectRoot, candidate),
+                    testCommand: command,
+                    detectionSource: "package_script_match",
+                };
+            }
+        }
+    }
+    return {
+        testWorkingDirectory: existingVerification?.testWorkingDirectory || ".",
+        testCommand: command,
+        detectionSource: "fallback_default",
+    };
+}
+function isRelativeDirectoryInsideProject(projectRoot, targetDirectory) {
+    const resolvedProjectRoot = resolve(projectRoot);
+    const resolvedTarget = resolve(projectRoot, targetDirectory);
+    return resolvedTarget === resolvedProjectRoot || resolvedTarget.startsWith(`${resolvedProjectRoot}/`);
+}
+function directoryExists(targetDirectory) {
+    try {
+        return statSync(targetDirectory).isDirectory();
+    }
+    catch {
+        return false;
+    }
+}
+function buildDefaultAudioSetup(existingProjectConfig) {
+    const existingAudio = existingProjectConfig.audio;
+    if (typeof existingAudio?.enabled === "boolean") {
+        return {
+            enabled: existingAudio.enabled,
+            playerCommand: existingAudio.playerCommand,
+            titleSound: existingAudio.titleSound,
+            encounterSound: existingAudio.encounterSound,
+            victorySound: existingAudio.victorySound,
+            detectionSource: "existing_config",
+        };
+    }
+    if (process.platform === "darwin") {
+        return {
+            enabled: false,
+            playerCommand: "afplay",
+            titleSound: "/System/Library/Sounds/Submarine.aiff",
+            encounterSound: "/System/Library/Sounds/Sosumi.aiff",
+            victorySound: "/System/Library/Sounds/Hero.aiff",
+            detectionSource: "interactive_default",
+        };
+    }
+    return {
+        enabled: false,
+        detectionSource: "disabled_default",
+    };
+}
+async function askVerificationSetup(projectRoot, detected, options) {
+    const explicitOverridesProvided = Boolean(String(options.testWorkingDirectory || "").trim() || String(options.testCommand || "").trim());
+    if (explicitOverridesProvided || !process.stdin.isTTY || !process.stdout.isTTY) {
+        return detected;
+    }
+    const rl = createInterface({ input: process.stdin, output: process.stdout });
+    try {
+        console.log(chalk.bold("\n  Verification Test Setup"));
+        console.log(chalk.dim(`  Default command: ${detected.testCommand}`));
+        console.log(chalk.dim(`  Default working directory: ${detected.testWorkingDirectory}`));
+        if (detected.detectionSource === "fallback_default") {
+            console.log(chalk.yellow("  Could not confidently detect the test package. Confirm these values before continuing."));
+        }
+        else {
+            console.log(chalk.dim(`  Detection source: ${detected.detectionSource}`));
+        }
+        let nextWorkingDirectory = detected.testWorkingDirectory;
+        while (true) {
+            const answer = (await rl.question(chalk.dim(`  Test working directory [${nextWorkingDirectory}]: `))).trim();
+            const candidate = answer || nextWorkingDirectory;
+            if (!isRelativeDirectoryInsideProject(projectRoot, candidate)) {
+                console.log(chalk.red("  Directory must stay inside the project root."));
+                continue;
+            }
+            const resolvedCandidate = resolve(projectRoot, candidate);
+            if (!directoryExists(resolvedCandidate)) {
+                console.log(chalk.red(`  Directory not found: ${candidate}`));
+                continue;
+            }
+            nextWorkingDirectory = normalizeRelativeDirectory(projectRoot, candidate);
+            break;
+        }
+        let nextCommand = detected.testCommand;
+        while (true) {
+            const answer = (await rl.question(chalk.dim(`  Test command [${nextCommand}]: `))).trim();
+            const candidate = answer || nextCommand;
+            if (!candidate.trim()) {
+                console.log(chalk.red("  Test command cannot be empty."));
+                continue;
+            }
+            nextCommand = candidate.trim();
+            break;
+        }
+        const detectionSource = nextWorkingDirectory !== detected.testWorkingDirectory || nextCommand !== detected.testCommand
+            ? "interactive_override"
+            : detected.detectionSource;
+        return {
+            testWorkingDirectory: nextWorkingDirectory,
+            testCommand: nextCommand,
+            detectionSource,
+        };
+    }
+    finally {
+        rl.close();
+    }
+}
+async function askAudioSetup(existingProjectConfig) {
+    const detected = buildDefaultAudioSetup(existingProjectConfig);
+    if (!process.stdin.isTTY || !process.stdout.isTTY) {
+        return detected;
+    }
+    if (process.platform !== "darwin") {
+        return detected;
+    }
+    const rl = createInterface({ input: process.stdin, output: process.stdout });
+    try {
+        console.log(chalk.bold("\n  Terminal Audio Setup"));
+        console.log(chalk.dim("  Optional macOS-only intro, encounter, and victory cues via afplay."));
+        const defaultAnswer = detected.enabled ? "Y/n" : "y/N";
+        const answer = (await rl.question(chalk.dim(`  Enable title/encounter/victory music in terminal? [${defaultAnswer}]: `))).trim().toLowerCase();
+        const wantsAudio = detected.enabled
+            ? !["n", "no"].includes(answer)
+            : ["y", "yes"].includes(answer);
+        if (!wantsAudio) {
+            return {
+                enabled: false,
+                detectionSource: detected.detectionSource === "existing_config" ? "existing_config" : "interactive_override",
+            };
+        }
+        return {
+            enabled: true,
+            playerCommand: detected.playerCommand ?? "afplay",
+            titleSound: detected.titleSound ?? "/System/Library/Sounds/Submarine.aiff",
+            encounterSound: detected.encounterSound ?? "/System/Library/Sounds/Sosumi.aiff",
+            victorySound: detected.victorySound ?? "/System/Library/Sounds/Hero.aiff",
+            detectionSource: detected.detectionSource === "existing_config" ? "existing_config" : "interactive_override",
+        };
+    }
+    finally {
+        rl.close();
+    }
+}
+async function askSetupPath(projectRoot) {
+    const detected = detectCutlineProject(projectRoot);
+    if (!process.stdin.isTTY || !process.stdout.isTTY) {
+        return {
+            mode: "new_character",
+            projectRoot,
+            projectName: detected.projectName,
+            productId: detected.productId,
+        };
+    }
+    const rl = createInterface({ input: process.stdin, output: process.stdout });
+    try {
+        console.log(chalk.bold("  Character Setup Menu"));
+        const projectLabel = detected.projectName
+            ? `${detected.projectName}${detected.productId ? ` (${detected.productId})` : ""}`
+            : projectRoot;
+        console.log(chalk.cyan("  1)"), `Use existing Cutline project: ${projectLabel}`);
+        console.log(chalk.cyan("  2)"), "Create a new character");
+        const pathAnswer = (await rl.question(chalk.dim("  Choose 1 or 2 [2]: "))).trim();
+        const useExisting = pathAnswer === "1";
+        if (useExisting) {
+            return {
+                mode: "existing_project",
+                projectRoot,
+                projectName: detected.projectName,
+                productId: detected.productId,
+            };
+        }
+        const rawName = (await rl.question(chalk.dim("  Character name: "))).trim();
+        const characterName = rawName || "Unnamed Adventurer";
+        console.log(chalk.dim("  Choose class:"));
+        CLASS_OPTIONS.forEach((option, idx) => {
+            console.log(chalk.cyan(`  ${idx + 1})`), option.label);
+        });
+        const classAnswer = (await rl.question(chalk.dim("  Pick 1-4 [1]: "))).trim();
+        const classIdx = Number.parseInt(classAnswer, 10);
+        const pickedClass = Number.isFinite(classIdx) && classIdx >= 1 && classIdx <= CLASS_OPTIONS.length
+            ? CLASS_OPTIONS[classIdx - 1].id
+            : "fighter";
+        return {
+            mode: "new_character",
+            projectRoot,
+            projectName: detected.projectName,
+            productId: detected.productId,
+            characterName,
+            characterClass: pickedClass,
+        };
+    }
+    finally {
+        rl.close();
+    }
+}
+function writeNaturalLanguageRule(projectRoot, selection) {
+    const rulesDir = join(projectRoot, ".cursor", "rules");
+    mkdirSync(rulesDir, { recursive: true });
+    const rulePath = join(rulesDir, "slopburn-intents.mdc");
+    const configuredCharacterBlock = selection.mode === "new_character" && selection.characterName && selection.characterClass
+        ? `
+## Configured Character Defaults
+- Character name: \`${selection.characterName}\`
+- Character class: \`${selection.characterClass}\`
+
+When the user asks to start/play SlopBurn without overriding character details:
+- Prefer the defaults stored in \`.cutline/slopburn.json\`.
+- If a direct MCP call still needs explicit values, include BOTH \`character_name\` and \`character_class\`.
+- If user explicitly asks for a different character, override these defaults.
+`
+        : "";
+    const content = `# SlopBurn Natural Language Intents
+
+When the user asks to play/start/resume SlopBurn, route to SlopBurn MCP tools directly.
+
+${configuredCharacterBlock}
+
+## Startup intents
+- "start slopburn", "start a run", "begin campaign", "new character"
+  -> call \`slopburn_start_run\` first
+- "resume slopburn", "resume campaign", "continue my run"
+  -> call \`slopburn_status\` with \`show_title_screen: true\`
+- "show my run", "campaign status", "where am I in the game"
+  -> call \`slopburn_status\`
+
+## Core gameplay intents
+- "take a turn", "continue narrative", "advance act"
+  -> call \`slopburn_take_turn\`
+- "roll tests", "roll the dice", "run dungeon checks"
+  -> call \`slopburn_roll_tests\`
+
+## Progression intents
+- "show spellbook", "list spells", "what can I equip"
+  -> call \`slopburn_spellbook_list\`
+- "install spell <id>"
+  -> call \`slopburn_spellbook_install\`
+- "equip spell <id>"
+  -> call \`slopburn_spellbook_equip\`
+- "choose perk <id>"
+  -> call \`slopburn_choose_perk\`
+
+## Guardrails
+- If the user asks to play but has no \`run_id\`, start with \`slopburn_start_run\`.
+- Use \`slopburn_bootstrap_run\` only when the run explicitly asks for Character Creation or onboarding continuation.
+- Prefer direct MCP tool calls over prose for actionable gameplay requests.
+- If \`game_over\` is returned, surface the game-over message and suggestions clearly.
+`;
+    writeFileSync(rulePath, `${content.trim()}\n`);
+    return rulePath;
+}
+function summarizeSelection(selection) {
+    if (selection.mode === "new_character") {
+        return `${selection.characterName ?? "Unnamed Adventurer"} (${selection.characterClass ?? "fighter"})`;
+    }
+    return selection.projectName
+        ? `existing project ${selection.projectName}`
+        : "existing Cutline project";
+}
+function mergeIdeConfig(filePath, serverConfig) {
+    let existing = {};
+    if (existsSync(filePath)) {
+        try {
+            existing = JSON.parse(readFileSync(filePath, "utf-8"));
+        }
+        catch {
+            existing = {};
+        }
+    }
+    else {
+        mkdirSync(join(filePath, ".."), { recursive: true });
+    }
+    const existingServers = (existing.mcpServers ?? {});
+    const cleaned = {};
+    for (const [key, value] of Object.entries(existingServers)) {
+        if (!key.startsWith("slopburn"))
+            cleaned[key] = value;
+    }
+    existing.mcpServers = { ...cleaned, ...serverConfig };
+    writeFileSync(filePath, `${JSON.stringify(existing, null, 2)}\n`);
+}
+export async function setupCommand(options) {
+    const channel = options.staging ? "staging" : "production";
+    const projectRoot = resolve(options.projectRoot ?? process.cwd());
+    const serverConfig = buildServerConfig(channel, projectRoot);
+    const projectConfigPath = getProjectGameConfigPath(projectRoot);
+    const existingProjectConfig = readProjectGameConfig(projectRoot);
+    const savedSelection = resolveSavedOnboarding(projectRoot);
+    const home = homedir();
+    const ideConfigs = [
+        { name: "Cursor", path: join(home, ".cursor", "mcp.json") },
+        { name: "Claude Code", path: join(home, ".claude.json") },
+    ];
+    const selection = savedSelection
+        ? {
+            ...savedSelection,
+            projectRoot,
+            projectName: savedSelection.projectName ?? detectCutlineProject(projectRoot).projectName,
+            productId: savedSelection.productId ?? detectCutlineProject(projectRoot).productId,
+        }
+        : await askSetupPath(projectRoot);
+    const reusedSavedConfig = Boolean(savedSelection);
+    const detectedVerificationConfig = detectVerificationConfig(projectRoot, options, existingProjectConfig);
+    const verificationConfig = await askVerificationSetup(projectRoot, detectedVerificationConfig, options);
+    const audioConfig = await askAudioSetup(existingProjectConfig);
+    for (const ide of ideConfigs) {
+        try {
+            mergeIdeConfig(ide.path, serverConfig);
+            if (options.verbose) {
+                console.log(chalk.green(`  ✓ ${ide.name}`), chalk.dim(ide.path));
+            }
+        }
+        catch (error) {
+            console.log(chalk.red(`  ✗ ${ide.name}`), chalk.dim(error?.message || "unknown error"));
+        }
+    }
+    writeSlopburnConfig({ channel });
+    writeProjectGameConfig(projectRoot, {
+        ...existingProjectConfig,
+        onboarding: {
+            ...selection,
+            projectRoot,
+        },
+        startup: {
+            quiet: existingProjectConfig.startup?.quiet ?? true,
+            autoResume: existingProjectConfig.startup?.autoResume ?? true,
+        },
+        verification: {
+            testWorkingDirectory: verificationConfig.testWorkingDirectory,
+            testCommand: verificationConfig.testCommand,
+        },
+        audio: audioConfig.enabled
+            ? {
+                enabled: true,
+                playerCommand: audioConfig.playerCommand,
+                titleSound: audioConfig.titleSound,
+                encounterSound: audioConfig.encounterSound,
+                victorySound: audioConfig.victorySound,
+            }
+            : { enabled: false },
+    });
+    ensureSlopburnProjectGitignore(projectRoot);
+    const rulePath = writeNaturalLanguageRule(projectRoot, selection);
+    let shouldServeNow = Boolean(options.serveNow);
+    if (!shouldServeNow && process.stdin.isTTY && process.stdout.isTTY) {
+        const rl = createInterface({ input: process.stdin, output: process.stdout });
+        try {
+            const answer = (await rl.question(chalk.dim("  Start SlopBurn server now? [Y/n]: "))).trim().toLowerCase();
+            shouldServeNow = !["n", "no"].includes(answer);
+        }
+        finally {
+            rl.close();
+        }
+    }
+    console.log(chalk.bold("\nSlopBurn setup ready.\n"));
+    console.log(chalk.green("  ✓"), reusedSavedConfig ? "Using saved game config" : "Saved game config", chalk.dim(projectConfigPath));
+    console.log(chalk.green("  ✓"), chalk.dim(`Profile: ${summarizeSelection(selection)} · channel ${channel}`));
+    console.log(chalk.green("  ✓"), chalk.dim(`Verification: ${verificationConfig.testCommand} @ ${verificationConfig.testWorkingDirectory}`));
+    console.log(chalk.green("  ✓"), chalk.dim(audioConfig.enabled
+        ? `Terminal audio: ${audioConfig.playerCommand} (${audioConfig.titleSound} / ${audioConfig.encounterSound} / ${audioConfig.victorySound})`
+        : "Terminal audio: disabled"));
+    if (options.verbose) {
+        console.log(chalk.green("  ✓ Rule"), chalk.dim(rulePath));
+        console.log(chalk.green("  ✓ MCP entry"), chalk.dim(`slopburn -> slopburn serve${channel === "staging" ? " --staging" : ""} --project-root ${projectRoot}`));
+        console.log(chalk.green("  ✓ Verification source"), chalk.dim(verificationConfig.detectionSource));
+        console.log(chalk.green("  ✓ Audio source"), chalk.dim(audioConfig.detectionSource));
+    }
+    if (shouldServeNow) {
+        console.log(chalk.dim(`  Refresh your MCP session, then say "${buildCanonicalPrompt(selection)}".\n`));
+        runCutlineCliWithEnv(["serve", "slopburn"], channel, {
+            SLOPBURN_PROJECT_ROOT: projectRoot,
+            SLOPBURN_QUIET_STARTUP: "1",
+        });
+        return;
+    }
+    console.log(chalk.dim(`  Next: run slopburn serve, refresh your MCP session, then say "${buildCanonicalPrompt(selection)}".\n`));
+}

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/index.js

@@ -0,0 +1,100 @@
+#!/usr/bin/env node
+import { Command } from "commander";
+import { readFileSync } from "node:fs";
+import { dirname, join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { resolveChannel } from "./utils/config.js";
+import { runCutlineCli, runCutlineCliWithEnv } from "./utils/runtime.js";
+import { setupCommand } from "./commands/setup.js";
+import { bootstrapCommand } from "./commands/bootstrap.js";
+import { eventCommand } from "./commands/event.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("slopburn")
+    .description("SlopBurn CLI: dedicated onboarding and run flow for the product quality engineering roguelike")
+    .version(pkg.version);
+program
+    .command("login")
+    .description("Authenticate using Cutline auth flow")
+    .option("--staging", "Use staging channel/package")
+    .action((opts) => {
+    const channel = resolveChannel(Boolean(opts.staging));
+    const args = ["login"];
+    if (channel === "staging")
+        args.push("--staging");
+    runCutlineCliWithEnv(args, channel, { CUTLINE_MCP_AUTH_SOURCE: "slopburn" });
+});
+program
+    .command("logout")
+    .description("Remove stored credentials")
+    .option("--staging", "Use staging channel/package")
+    .action((opts) => {
+    const channel = resolveChannel(Boolean(opts.staging));
+    const args = ["logout"];
+    if (channel === "staging")
+        args.push("--staging");
+    runCutlineCli(args, channel);
+});
+program
+    .command("status")
+    .description("Show authentication/subscription status")
+    .option("--staging", "Use staging channel/package")
+    .action((opts) => {
+    const channel = resolveChannel(Boolean(opts.staging));
+    const args = ["status"];
+    if (channel === "staging")
+        args.push("--staging");
+    runCutlineCli(args, channel);
+});
+program
+    .command("setup")
+    .description("Write dedicated SlopBurn MCP config and persist channel preference")
+    .option("--staging", "Use staging channel/package")
+    .option("--project-root <path>", "Project root for generated natural-language rules (default: cwd)")
+    .option("--test-working-directory <path>", "Directory to run verification tests from, relative to project root")
+    .option("--test-command <command>", "Command used for local verification rolls")
+    .option("--serve-now", "Immediately start SlopBurn MCP server after setup")
+    .option("--verbose", "Show expanded setup output")
+    .action(setupCommand);
+program
+    .command("serve")
+    .description("Serve only the SlopBurn MCP server")
+    .option("--staging", "Use staging channel/package")
+    .option("--project-root <path>", "Project root containing .cutline/slopburn.json (default: cwd)")
+    .option("--http", "Expose over HTTP bridge")
+    .option("--host <host>", "HTTP bind host")
+    .option("--port <port>", "HTTP bind port")
+    .option("--path <path>", "HTTP MCP path")
+    .option("--verbose", "Print the SlopBurn stdio startup banner")
+    .action((opts) => {
+    const channel = resolveChannel(Boolean(opts.staging));
+    const args = ["serve", "slopburn"];
+    if (opts.http)
+        args.push("--http");
+    if (opts.host)
+        args.push("--host", String(opts.host));
+    if (opts.port)
+        args.push("--port", String(opts.port));
+    if (opts.path)
+        args.push("--path", String(opts.path));
+    const projectRoot = resolve(String(opts.projectRoot || process.cwd()));
+    runCutlineCliWithEnv(args, channel, {
+        SLOPBURN_PROJECT_ROOT: projectRoot,
+        SLOPBURN_QUIET_STARTUP: opts.verbose ? "0" : "1",
+    });
+});
+program
+    .command("bootstrap")
+    .description("Print first-run MCP bootstrap sequence")
+    .option("--project-root <path>", "Project root containing .cutline/slopburn.json (default: cwd)")
+    .option("--full", "Show the full MCP tool sequence and extra prompts")
+    .action(bootstrapCommand);
+program
+    .command("event <type>")
+    .description("Render local terminal event banner or audio cue (title | level-up | game-over | encounter | victory)")
+    .option("--project-root <path>", "Project root containing .cutline/slopburn.json (default: cwd)")
+    .action(eventCommand);
+program.parse();

package/dist/utils/config.d.ts

@@ -0,0 +1,45 @@
+import type { CliChannel } from "./runtime.js";
+export type SlopburnSetupMode = "existing_project" | "new_character";
+export type SlopburnCharacterClass = "fighter" | "wizard" | "rogue" | "paladin";
+export interface SlopburnOnboardingConfig {
+    mode: SlopburnSetupMode;
+    projectRoot?: string;
+    projectName?: string;
+    productId?: string;
+    characterSlotId?: string;
+    characterName?: string;
+    characterClass?: SlopburnCharacterClass;
+    playStyle?: "immersive" | "direct";
+}
+export interface SlopburnCliConfig {
+    channel?: CliChannel;
+    onboarding?: SlopburnOnboardingConfig;
+}
+export interface SlopburnProjectGameConfig {
+    version?: 1;
+    onboarding?: SlopburnOnboardingConfig;
+    startup?: {
+        quiet?: boolean;
+        autoResume?: boolean;
+    };
+    verification?: {
+        testWorkingDirectory?: string;
+        testCommand?: string;
+    };
+    audio?: {
+        enabled?: boolean;
+        playerCommand?: string;
+        titleSound?: string;
+        encounterSound?: string;
+        victorySound?: string;
+    };
+    updatedAt?: string;
+}
+export declare function readSlopburnConfig(): SlopburnCliConfig;
+export declare function writeSlopburnConfig(partial: SlopburnCliConfig): void;
+export declare function resolveChannel(explicitStaging?: boolean): CliChannel;
+export declare function getProjectGameConfigPath(projectRoot: string): string;
+export declare function readProjectGameConfig(projectRoot: string): SlopburnProjectGameConfig;
+export declare function writeProjectGameConfig(projectRoot: string, partial: SlopburnProjectGameConfig): void;
+export declare function ensureSlopburnProjectGitignore(projectRoot: string): void;
+export declare function resolveSavedOnboarding(projectRoot: string): SlopburnOnboardingConfig | null;

package/dist/utils/config.js

@@ -0,0 +1,98 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join, resolve } from "node:path";
+const CONFIG_DIR = join(homedir(), ".slopburn");
+const CONFIG_PATH = join(CONFIG_DIR, "config.json");
+const PROJECT_CONFIG_RELATIVE_PATH = join(".cutline", "slopburn.json");
+const SLOPBURN_DUNGEON_GITIGNORE_ENTRY = ".cutline/slopburn/";
+export function readSlopburnConfig() {
+    try {
+        if (!existsSync(CONFIG_PATH))
+            return {};
+        const raw = readFileSync(CONFIG_PATH, "utf-8");
+        const parsed = JSON.parse(raw);
+        return parsed && typeof parsed === "object" ? parsed : {};
+    }
+    catch {
+        return {};
+    }
+}
+export function writeSlopburnConfig(partial) {
+    const existing = readSlopburnConfig();
+    const next = {
+        ...existing,
+        ...partial,
+        onboarding: partial.onboarding ?? existing.onboarding,
+    };
+    mkdirSync(CONFIG_DIR, { recursive: true });
+    writeFileSync(CONFIG_PATH, `${JSON.stringify(next, null, 2)}\n`);
+}
+export function resolveChannel(explicitStaging) {
+    if (explicitStaging)
+        return "staging";
+    const cfg = readSlopburnConfig();
+    return cfg.channel ?? "production";
+}
+export function getProjectGameConfigPath(projectRoot) {
+    return join(resolve(projectRoot), PROJECT_CONFIG_RELATIVE_PATH);
+}
+function readJsonFile(filePath) {
+    try {
+        if (!existsSync(filePath))
+            return null;
+        const raw = readFileSync(filePath, "utf-8");
+        const parsed = JSON.parse(raw);
+        return parsed && typeof parsed === "object" ? parsed : null;
+    }
+    catch {
+        return null;
+    }
+}
+export function readProjectGameConfig(projectRoot) {
+    return readJsonFile(getProjectGameConfigPath(projectRoot)) ?? {};
+}
+export function writeProjectGameConfig(projectRoot, partial) {
+    const existing = readProjectGameConfig(projectRoot);
+    const next = {
+        ...existing,
+        ...partial,
+        onboarding: partial.onboarding ?? existing.onboarding,
+        startup: partial.startup ?? existing.startup,
+        verification: partial.verification ?? existing.verification,
+        audio: partial.audio ?? existing.audio,
+        version: 1,
+        updatedAt: new Date().toISOString(),
+    };
+    const configPath = getProjectGameConfigPath(projectRoot);
+    mkdirSync(join(configPath, ".."), { recursive: true });
+    writeFileSync(configPath, `${JSON.stringify(next, null, 2)}\n`);
+}
+export function ensureSlopburnProjectGitignore(projectRoot) {
+    const ignorePath = join(resolve(projectRoot), ".gitignore");
+    const existing = existsSync(ignorePath) ? readFileSync(ignorePath, "utf-8") : "";
+    if (existing.split(/\r?\n/).includes(SLOPBURN_DUNGEON_GITIGNORE_ENTRY))
+        return;
+    const suffix = existing.endsWith("\n") || existing.length === 0 ? "" : "\n";
+    const block = `${suffix}# SlopBurn local dungeon state\n${SLOPBURN_DUNGEON_GITIGNORE_ENTRY}\n`;
+    writeFileSync(ignorePath, `${existing}${block}`);
+}
+export function resolveSavedOnboarding(projectRoot) {
+    const projectConfig = readProjectGameConfig(projectRoot);
+    if (projectConfig.onboarding?.mode) {
+        return {
+            ...projectConfig.onboarding,
+            projectRoot: resolve(projectConfig.onboarding.projectRoot ?? projectRoot),
+        };
+    }
+    const globalConfig = readSlopburnConfig();
+    const legacy = globalConfig.onboarding;
+    if (!legacy?.mode)
+        return null;
+    const legacyRoot = legacy.projectRoot ? resolve(legacy.projectRoot) : null;
+    if (legacyRoot && legacyRoot !== resolve(projectRoot))
+        return null;
+    return {
+        ...legacy,
+        projectRoot: resolve(projectRoot),
+    };
+}

package/dist/utils/runtime.d.ts

@@ -0,0 +1,4 @@
+export type CliChannel = "production" | "staging";
+export declare function packageForChannel(channel: CliChannel): string;
+export declare function runCutlineCli(args: string[], channel: CliChannel): never;
+export declare function runCutlineCliWithEnv(args: string[], channel: CliChannel, extraEnv: Record<string, string>): never;

package/dist/utils/runtime.js

@@ -0,0 +1,61 @@
+import { spawnSync } from "node:child_process";
+import { readFileSync } from "node:fs";
+import { dirname, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+export function packageForChannel(channel) {
+    return channel === "staging"
+        ? "@vibekiln/cutline-mcp-cli-staging"
+        : "@vibekiln/cutline-mcp-cli";
+}
+function runInstalledCutlineCli(args, channel, env) {
+    const pkg = packageForChannel(channel);
+    try {
+        const __filename = fileURLToPath(import.meta.url);
+        const __dirname = dirname(__filename);
+        const packageRoot = resolve(__dirname, "..", "..");
+        const packageJsonPath = resolve(packageRoot, "node_modules", pkg, "package.json");
+        const packageJson = JSON.parse(readFileSync(packageJsonPath, "utf-8"));
+        const binPath = typeof packageJson.bin === "string"
+            ? packageJson.bin
+            : packageJson.bin?.["cutline-mcp"];
+        if (!binPath)
+            return null;
+        const entry = resolve(packageRoot, "node_modules", pkg, binPath);
+        const result = spawnSync(process.execPath, [entry, ...args], {
+            stdio: "inherit",
+            env,
+        });
+        if (result.error)
+            return null;
+        return result.status ?? 0;
+    }
+    catch {
+        return null;
+    }
+}
+function runViaNpx(args, channel, env) {
+    const pkg = packageForChannel(channel);
+    const result = spawnSync("npx", ["-y", pkg, ...args], {
+        stdio: "inherit",
+        env,
+    });
+    if (result.error) {
+        console.error(result.error.message);
+        return 1;
+    }
+    return result.status ?? 0;
+}
+export function runCutlineCli(args, channel) {
+    const localStatus = runInstalledCutlineCli(args, channel, process.env);
+    const exitCode = localStatus ?? runViaNpx(args, channel, process.env);
+    process.exit(exitCode);
+}
+export function runCutlineCliWithEnv(args, channel, extraEnv) {
+    const mergedEnv = {
+        ...process.env,
+        ...extraEnv,
+    };
+    const localStatus = runInstalledCutlineCli(args, channel, mergedEnv);
+    const exitCode = localStatus ?? runViaNpx(args, channel, mergedEnv);
+    process.exit(exitCode);
+}

package/package.json

@@ -0,0 +1,36 @@
+{
+  "name": "@vibekiln/slopburn-cli-staging",
+  "version": "0.1.0",
+  "description": "First-class SlopBurn CLI with dedicated onboarding and MCP config, powered by Cutline components.",
+  "type": "module",
+  "main": "dist/index.js",
+  "bin": {
+    "slopburn": "dist/index.js"
+  },
+  "files": [
+    "dist/**/*",
+    "README.md"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsc --watch",
+    "start": "node dist/index.js",
+    "prepublishOnly": "npm run build"
+  },
+  "dependencies": {
+    "@vibekiln/cutline-mcp-cli": "^0.13.0",
+    "@vibekiln/cutline-mcp-cli-staging": "^0.5.0",
+    "chalk": "^4.1.2",
+    "commander": "^11.1.0"
+  },
+  "devDependencies": {
+    "@types/node": "^20.0.0",
+    "typescript": "^5.3.0"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}