@evitcastudio/kit 3.1.1 → 3.2.0

package/lib/cli/create.js

@@ -0,0 +1,88 @@
+import { promises as fs } from 'node:fs';
+import { join } from 'node:path';
+import chalk from 'chalk';
+/**
+ * Formats a given name into a PascalCase class name.
+ * @param pName - Raw identifier input.
+ */
+function toPascalCase(pName) {
+    return pName
+        .replace(/[-_](\w)/g, (_, c) => c.toUpperCase())
+        .replace(/^\w/, c => c.toUpperCase());
+}
+/**
+ * Formats a given name into a kebab-case file name.
+ * @param pName - Raw identifier input.
+ */
+function toKebabCase(pName) {
+    return pName
+        .replace(/([a-z])([A-Z])/g, '$1-$2')
+        .replace(/[\s_]+/g, '-')
+        .toLowerCase();
+}
+/**
+ * Generates the source code for a custom KitPlugin.
+ * @param pClassName - PascalCase class name.
+ * @param pPluginName - Plugin string identifier.
+ */
+function generatePluginSource(pClassName, pPluginName) {
+    return `import { KitPlugin } from '@evitcastudio/kit';
+
+/**
+ * ${pClassName} plugin for the Kit framework.
+ */
+export class ${pClassName} extends KitPlugin {
+    /**
+     * Unique name identifier of the plugin.
+     */
+    readonly name = '${pPluginName}';
+
+    /**
+     * Entry point for custom initialization when the plugin is registered with Kit.
+     */
+    onRegistered(): void {
+        // Initialize plugin logic
+    }
+}
+`;
+}
+/**
+ * Handles creation of new boilerplate elements in a Kit project.
+ * @param pOptions - Creation configuration options.
+ */
+export async function processCreate(pOptions) {
+    const { type, name, verbose } = pOptions;
+    if (!type || !name) {
+        console.error(chalk.red('\nError: Both type and name are required. Usage: kit create <type> <name>'));
+        process.exit(1);
+    }
+    const normalizedType = type.toLowerCase();
+    if (normalizedType !== 'plugin') {
+        console.error(chalk.red(`\nError: Unknown create type '${type}'. Supported types: 'plugin'`));
+        process.exit(1);
+    }
+    const className = toPascalCase(name);
+    const fileName = `${toKebabCase(name)}.ts`;
+    // Standard location for plugins in a game or library project
+    const pluginsDir = join(process.cwd(), 'src', 'plugins');
+    const targetPath = join(pluginsDir, fileName);
+    try {
+        await fs.mkdir(pluginsDir, { recursive: true });
+        const fileExists = await fs.stat(targetPath).then(() => true).catch(() => false);
+        if (fileExists) {
+            console.error(chalk.red(`\nError: File already exists at ${targetPath}`));
+            process.exit(1);
+        }
+        const sourceCode = generatePluginSource(className, className);
+        await fs.writeFile(targetPath, sourceCode, 'utf8');
+        console.log(`\n  ${chalk.green('✓')} Created plugin ${chalk.cyan(className)} at ${chalk.dim(targetPath)}\n`);
+        if (verbose) {
+            console.log(chalk.dim(sourceCode));
+        }
+    }
+    catch (pError) {
+        const message = pError instanceof Error ? pError.message : String(pError);
+        console.error(chalk.red(`\nError creating plugin: ${message}`));
+        process.exit(1);
+    }
+}

package/lib/cli/doctor.d.ts

@@ -0,0 +1,9 @@
+export interface DoctorOptions {
+    verbose?: boolean;
+}
+/**
+ * Runs diagnostics on the local development environment and project health.
+ * @param pOptions - Options passed from the CLI.
+ */
+export declare function processDoctor(pOptions?: DoctorOptions): Promise<boolean>;
+//# sourceMappingURL=doctor.d.ts.map

package/lib/cli/doctor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"doctor.d.ts","sourceRoot":"","sources":["../../src/cli/doctor.ts"],"names":[],"mappings":"AAKA,MAAM,WAAW,aAAa;IAC1B,OAAO,CAAC,EAAE,OAAO,CAAC;CACrB;AASD;;;GAGG;AACH,wBAAsB,aAAa,CAAC,QAAQ,GAAE,aAAkB,GAAG,OAAO,CAAC,OAAO,CAAC,CAiLlF"}

package/lib/cli/doctor.js

@@ -0,0 +1,179 @@
+import { spawnSync } from 'node:child_process';
+import { existsSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import chalk from 'chalk';
+/**
+ * Runs diagnostics on the local development environment and project health.
+ * @param pOptions - Options passed from the CLI.
+ */
+export async function processDoctor(pOptions = {}) {
+    const isVerbose = Boolean(pOptions.verbose);
+    const results = [];
+    console.log(`\n  ${chalk.cyan.bold('Kit Doctor')} ${chalk.dim('-')} Environment & Project Health Check\n`);
+    // 1. Runtime Check: Bun
+    const bunCheck = spawnSync('bun', ['--version'], { encoding: 'utf8', shell: true });
+    if (!bunCheck.error && bunCheck.status === 0) {
+        results.push({
+            category: 'Runtime',
+            title: 'Bun Runtime',
+            passed: true,
+            details: `Installed version v${bunCheck.stdout.trim()}`
+        });
+    }
+    else {
+        results.push({
+            category: 'Runtime',
+            title: 'Bun Runtime',
+            passed: false,
+            details: 'Bun is not installed or not in PATH. Download at https://bun.sh/'
+        });
+    }
+    // 2. Version Control Check: Git
+    const gitCheck = spawnSync('git', ['--version'], { encoding: 'utf8', shell: true });
+    if (!gitCheck.error && gitCheck.status === 0) {
+        results.push({
+            category: 'VCS',
+            title: 'Git Installation',
+            passed: true,
+            details: gitCheck.stdout.trim()
+        });
+    }
+    else {
+        results.push({
+            category: 'VCS',
+            title: 'Git Installation',
+            passed: false,
+            details: 'Git was not found in your PATH.'
+        });
+    }
+    // 3. Project Environment Check
+    const cwd = process.cwd();
+    const pkgPath = join(cwd, 'package.json');
+    const hasPackageJson = existsSync(pkgPath);
+    if (hasPackageJson) {
+        try {
+            const rawPkg = readFileSync(pkgPath, 'utf8');
+            const pkg = JSON.parse(rawPkg);
+            const hasKitDependency = Boolean((pkg.dependencies && pkg.dependencies['@evitcastudio/kit']) ||
+                (pkg.devDependencies && pkg.devDependencies['@evitcastudio/kit']) ||
+                pkg.name === '@evitcastudio/kit');
+            results.push({
+                category: 'Project',
+                title: 'package.json configuration',
+                passed: true,
+                details: `Project name: ${pkg.name || 'unnamed'}`
+            });
+            results.push({
+                category: 'Project',
+                title: 'Kit framework dependency',
+                passed: hasKitDependency,
+                details: hasKitDependency
+                    ? 'Found @evitcastudio/kit in project configuration'
+                    : 'Missing @evitcastudio/kit dependency in package.json'
+            });
+            // If running inside a consumer game project, check game asset directory structure
+            const isKitCoreRepo = pkg.name === '@evitcastudio/kit';
+            if (!isKitCoreRepo) {
+                const resourcesDir = join(cwd, 'src', 'resources');
+                const hasResources = existsSync(resourcesDir);
+                results.push({
+                    category: 'Project',
+                    title: 'Asset Directory (src/resources)',
+                    passed: hasResources,
+                    details: hasResources ? 'Asset directory present' : 'src/resources not found'
+                });
+            }
+            // Detect project type (multiplayer vs single-player)
+            const hasClientEntry = existsSync(join(cwd, 'src', 'client', 'index.ts'));
+            const hasServerEntry = existsSync(join(cwd, 'src', 'server', 'index.ts'));
+            const hasSingleEntry = existsSync(join(cwd, 'src', 'index.ts'));
+            let projectType = 'Unknown';
+            if (hasClientEntry && hasServerEntry) {
+                projectType = 'Multiplayer (Client & Server)';
+            }
+            else if (hasClientEntry) {
+                projectType = 'Multiplayer (Client)';
+            }
+            else if (hasServerEntry) {
+                projectType = 'Dedicated Server';
+            }
+            else if (hasSingleEntry) {
+                projectType = 'Singleplayer';
+            }
+            results.push({
+                category: 'Project',
+                title: 'Project Architecture',
+                passed: projectType !== 'Unknown' || isKitCoreRepo,
+                details: isKitCoreRepo ? 'Kit Core Framework Repository' : `Detected Type: ${projectType}`
+            });
+        }
+        catch {
+            results.push({
+                category: 'Project',
+                title: 'package.json format',
+                passed: false,
+                details: 'package.json is malformed or invalid JSON'
+            });
+        }
+        // Check for build script: either bun-build.ts exists, or package.json has a build script using kit build
+        const buildScript = join(cwd, 'bun-build.ts');
+        const hasBuildScript = existsSync(buildScript);
+        let hasKitBuildScript = false;
+        try {
+            const rawPkg = readFileSync(pkgPath, 'utf8');
+            const pkg = JSON.parse(rawPkg);
+            if (pkg.scripts && typeof pkg.scripts.build === 'string' && pkg.scripts.build.includes('kit build')) {
+                hasKitBuildScript = true;
+            }
+        }
+        catch {
+            // Ignored, handled above
+        }
+        const buildPipelinePassed = hasBuildScript || hasKitBuildScript;
+        let buildDetails = 'No build pipeline configured';
+        if (hasKitBuildScript && hasBuildScript) {
+            buildDetails = 'Kit CLI build pipeline with bun-build.ts present';
+        }
+        else if (hasKitBuildScript) {
+            buildDetails = 'Kit CLI native build pipeline configured';
+        }
+        else if (hasBuildScript) {
+            buildDetails = 'Legacy bun-build.ts present';
+        }
+        results.push({
+            category: 'Project',
+            title: 'Build Pipeline',
+            passed: buildPipelinePassed,
+            details: buildDetails
+        });
+    }
+    else {
+        results.push({
+            category: 'Project',
+            title: 'Project Context',
+            passed: true,
+            details: 'Not currently executed inside a Node/Bun project root.'
+        });
+    }
+    // Render results
+    let allPassed = true;
+    for (const res of results) {
+        const icon = res.passed ? chalk.green('✓') : chalk.red('✗');
+        const titleText = res.passed ? chalk.white(res.title) : chalk.red.bold(res.title);
+        console.log(`  ${icon} [${chalk.cyan(res.category)}] ${titleText}`);
+        if (res.details && (!res.passed || isVerbose)) {
+            console.log(`    ${chalk.dim(res.details)}`);
+        }
+        if (!res.passed) {
+            allPassed = false;
+        }
+    }
+    console.log('\n');
+    if (allPassed) {
+        console.log(`  ${chalk.green.bold('All doctor diagnostics passed!')}\n`);
+    }
+    else {
+        console.log(`  ${chalk.yellow.bold('Some issues were detected. Check the items above.')}\n`);
+    }
+    return allPassed;
+}

package/lib/cli/host.d.ts

@@ -0,0 +1,49 @@
+/**
+ * Options for hosting the project.
+ */
+export interface HostOptions {
+    /**
+     * Port to bind the server to (default: 8090).
+     */
+    port?: number;
+    /**
+     * Directory containing built files to serve (default: ./dist).
+     */
+    directory?: string;
+    /**
+     * Whether to trigger a build before hosting (default: false).
+     */
+    build?: boolean;
+    /**
+     * Whether to log detailed server events.
+     */
+    verbose?: boolean;
+}
+/**
+ * Result of the host process.
+ */
+export interface HostResult {
+    /**
+     * Whether the host process started successfully.
+     */
+    success: boolean;
+    /**
+     * Explanation of the result or error message.
+     */
+    message: string;
+    /**
+     * Server instance if static HTTP server was started.
+     */
+    server?: {
+        stop(): void;
+        port: number;
+    };
+}
+/**
+ * Hosts the game application via local HTTP server (for singleplayer/client games)
+ * or launches the multiplayer node server. Handles missing files gracefully.
+ * @param pOptions - Host options.
+ * @returns HostResult indicating success or failure message.
+ */
+export declare function processHost(pOptions?: HostOptions): Promise<HostResult>;
+//# sourceMappingURL=host.d.ts.map

package/lib/cli/host.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"host.d.ts","sourceRoot":"","sources":["../../src/cli/host.ts"],"names":[],"mappings":"AAMA;;GAEG;AACH,MAAM,WAAW,WAAW;IACxB;;OAEG;IACH,IAAI,CAAC,EAAE,MAAM,CAAC;IACd;;OAEG;IACH,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB;;OAEG;IACH,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB;;OAEG;IACH,OAAO,CAAC,EAAE,OAAO,CAAC;CACrB;AAED;;GAEG;AACH,MAAM,WAAW,UAAU;IACvB;;OAEG;IACH,OAAO,EAAE,OAAO,CAAC;IACjB;;OAEG;IACH,OAAO,EAAE,MAAM,CAAC;IAChB;;OAEG;IACH,MAAM,CAAC,EAAE;QAAE,IAAI,IAAI,IAAI,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAE,CAAC;CAC3C;AAoBD;;;;;GAKG;AACH,wBAAsB,WAAW,CAAC,QAAQ,GAAE,WAAgB,GAAG,OAAO,CAAC,UAAU,CAAC,CAiHjF"}

package/lib/cli/host.js

@@ -0,0 +1,127 @@
+import { existsSync, readFileSync } from 'fs';
+import { join, resolve } from 'path';
+import { networkInterfaces } from 'os';
+import chalk from 'chalk';
+import { detectArchitecture } from './app-bundler';
+/**
+ * Retrieves the primary local IPv4 address for local network access.
+ * @returns Primary LAN IPv4 address or localhost fallback.
+ */
+function getNetworkAddress() {
+    const interfaces = networkInterfaces();
+    for (const name of Object.keys(interfaces)) {
+        const netList = interfaces[name];
+        if (!netList)
+            continue;
+        for (const net of netList) {
+            if (net.family === 'IPv4' && !net.internal) {
+                return net.address;
+            }
+        }
+    }
+    return 'localhost';
+}
+/**
+ * Hosts the game application via local HTTP server (for singleplayer/client games)
+ * or launches the multiplayer node server. Handles missing files gracefully.
+ * @param pOptions - Host options.
+ * @returns HostResult indicating success or failure message.
+ */
+export async function processHost(pOptions = {}) {
+    const cwd = process.cwd();
+    const defaultPort = 8090;
+    const port = pOptions.port || defaultPort;
+    const distDir = pOptions.directory ? resolve(pOptions.directory) : join(cwd, 'dist');
+    const architecture = detectArchitecture(join(cwd, 'src'));
+    if (!existsSync(distDir)) {
+        const message = `Target directory "${distDir}" does not exist. Run "kit build" or use "kit host -b" first.`;
+        console.error(chalk.red(`\n[Kit Host] ${message}\n`));
+        return { success: false, message };
+    }
+    // Multiplayer Hosting
+    if (architecture === 'multi') {
+        const serverJsPath = join(distDir, 'server.js');
+        if (!existsSync(serverJsPath)) {
+            const message = `Cannot host multiplayer project: "${serverJsPath}" was not found. Please compile the server first using "kit build".`;
+            console.error(chalk.red(`\n[Kit Host] ${message}\n`));
+            return { success: false, message };
+        }
+        console.log(chalk.cyan(`\n🎮 Starting Multiplayer Server from ${chalk.bold(distDir)}...\n`));
+        let serverSettingsPort = port;
+        const settingsPath = join(distDir, 'settings.json');
+        if (existsSync(settingsPath)) {
+            try {
+                const settings = JSON.parse(readFileSync(settingsPath, 'utf8'));
+                if (settings.port)
+                    serverSettingsPort = Number(settings.port);
+            }
+            catch {
+                // Ignore fallback to default port
+            }
+        }
+        const proc = Bun.spawn(['node', 'server.js'], {
+            cwd: distDir,
+            stdout: 'inherit',
+            stderr: 'inherit',
+            stdin: 'inherit'
+        });
+        console.log(chalk.green(`✓ Multiplayer server process spawned (configured port: ${serverSettingsPort})`));
+        process.on('SIGINT', () => {
+            proc.kill();
+            process.exit(0);
+        });
+        process.on('SIGTERM', () => {
+            proc.kill();
+            process.exit(0);
+        });
+        await proc.exited;
+        return { success: true, message: 'Multiplayer server finished running.' };
+    }
+    // Singleplayer / Client static web hosting
+    const indexPath = join(distDir, 'index.html');
+    if (!existsSync(indexPath)) {
+        const message = `Missing entrypoint: "${indexPath}" was not found in dist. Run "kit build" or use "kit host -b" to compile.`;
+        console.error(chalk.red(`\n[Kit Host] ${message}\n`));
+        return { success: false, message };
+    }
+    const lanIp = getNetworkAddress();
+    const server = Bun.serve({
+        port,
+        async fetch(pReq) {
+            const path = new URL(pReq.url).pathname;
+            const target = path === '/' ? '/index.html' : decodeURIComponent(path);
+            const file = Bun.file(join(distDir, target));
+            if (!await file.exists()) {
+                if (pOptions.verbose) {
+                    console.warn(chalk.yellow(`[Kit Host] 404 Not Found: ${target}`));
+                }
+                return new Response('Not Found', { status: 404 });
+            }
+            return new Response(file);
+        }
+    });
+    console.log(chalk.cyan('\n🎮 Kit Game Host Server\n'));
+    console.log(`  ${chalk.bold('Local:')}    ${chalk.green(`http://localhost:${server.port}`)}`);
+    if (lanIp !== 'localhost') {
+        console.log(`  ${chalk.bold('Network:')}  ${chalk.green(`http://${lanIp}:${server.port}`)}`);
+    }
+    console.log(chalk.dim(`\nServing files from: ${distDir}`));
+    console.log(chalk.dim('Press Ctrl+C to stop the server\n'));
+    process.on('SIGINT', () => {
+        console.log(chalk.yellow('\nShutting down host server...'));
+        server.stop();
+        process.exit(0);
+    });
+    process.on('SIGTERM', () => {
+        server.stop();
+        process.exit(0);
+    });
+    return {
+        success: true,
+        message: `Serving files on port ${server.port}`,
+        server: {
+            stop: () => server.stop(),
+            port: server.port
+        }
+    };
+}

package/lib/cli/init.d.ts

@@ -5,6 +5,8 @@ export interface InitOptions {
     projectName?: string;
     single?: boolean;
     multi?: boolean;
+    force?: boolean;
+    install?: boolean;
     verbose?: boolean;
 }
 /**

package/lib/cli/init.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"init.d.ts","sourceRoot":"","sources":["../../src/cli/init.ts"],"names":[],"mappings":"AASA;;GAEG;AACH,MAAM,WAAW,WAAW;IACxB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,OAAO,CAAC,EAAE,OAAO,CAAC;CACrB;AAyFD;;;GAGG;AACH,wBAAsB,WAAW,CAAC,QAAQ,EAAE,WAAW,GAAG,OAAO,CAAC,IAAI,CAAC,CA8JtE"}
+{"version":3,"file":"init.d.ts","sourceRoot":"","sources":["../../src/cli/init.ts"],"names":[],"mappings":"AASA;;GAEG;AACH,MAAM,WAAW,WAAW;IACxB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,OAAO,CAAC,EAAE,OAAO,CAAC;CACrB;AAyFD;;;GAGG;AACH,wBAAsB,WAAW,CAAC,QAAQ,EAAE,WAAW,GAAG,OAAO,CAAC,IAAI,CAAC,CAwLtE"}

package/lib/cli/init.js

@@ -115,8 +115,10 @@ export async function processInit(pOptions) {
     }
     let projectName = pOptions.projectName;
     let gameType = 'single';
+    let shouldInstall = Boolean(pOptions.install);
+    const isInteractive = !pOptions.single && !pOptions.multi && !projectName;
     // Interactive Walkthrough
-    if (!pOptions.single && !pOptions.multi && !projectName) {
+    if (isInteractive) {
         const name = await text({
             message: 'What is the name of your project?',
             placeholder: 'my-amazing-project',
@@ -145,6 +147,13 @@ export async function processInit(pOptions) {
             process.exit(0);
         }
         gameType = type;
+        const installChoice = await confirm({
+            message: 'Install dependencies with Bun now?',
+            initialValue: true,
+        });
+        if (!isCancel(installChoice)) {
+            shouldInstall = Boolean(installChoice);
+        }
     }
     else {
         // Handle flags
@@ -159,13 +168,19 @@ export async function processInit(pOptions) {
     }
     const projectDir = path.join(process.cwd(), projectName);
     if (fs.existsSync(projectDir)) {
-        const overwrite = await confirm({
-            message: `Directory ${chalk.cyan(projectName)} already exists. Overwrite?`,
-            initialValue: false,
-        });
-        if (isCancel(overwrite) || !overwrite) {
-            cancel('Installation aborted.');
-            process.exit(0);
+        if (isInteractive) {
+            const overwrite = await confirm({
+                message: `Directory ${chalk.cyan(projectName)} already exists. Overwrite?`,
+                initialValue: false,
+            });
+            if (isCancel(overwrite) || !overwrite) {
+                cancel('Installation aborted.');
+                process.exit(0);
+            }
+        }
+        else if (!pOptions.force) {
+            console.error(chalk.red(`\nError: Destination directory '${projectName}' already exists. Use --force (-f) to overwrite.`));
+            process.exit(1);
         }
     }
     const s = spinner();
@@ -173,8 +188,6 @@ export async function processInit(pOptions) {
     try {
         const projectPath = path.join(process.cwd(), projectName);
         if (fs.existsSync(projectPath)) {
-            // This case should ideally be handled by the confirm prompt above,
-            // but good to have a fallback for non-interactive mode or race conditions.
             fs.rmSync(projectPath, { recursive: true, force: true });
         }
         fs.mkdirSync(projectPath, { recursive: true });
@@ -183,12 +196,9 @@ export async function processInit(pOptions) {
         if (gameType === 'both')
             templateType = 'multi'; // Use multi for both for now
         // Resolve template path
-        // When running from lib/bundle/cli/cli.js, templates are in ./kit-game-templates/
         const templatesDir = path.join(path.dirname(fileURLToPath(import.meta.url)), 'kit-game-templates', templateType);
         const author = getGitUser();
         if (!fs.existsSync(templatesDir)) {
-            // Fallback for local development (src/cli/init.ts)
-            // Go up to root then templates/pType
             const localTemplatesDir = path.join(process.cwd(), 'kit-game-templates', templateType);
             if (!fs.existsSync(localTemplatesDir)) {
                 console.error(chalk.red(`Error: Templates not found at ${templatesDir} or ${localTemplatesDir}`));
@@ -212,11 +222,28 @@ export async function processInit(pOptions) {
             // Silently fail if git is not installed or config is missing 
         }
         s.stop(`Project ${chalk.green(projectName)} created!`);
+        // Automatically install dependencies if requested
+        if (shouldInstall) {
+            const installSpinner = spinner();
+            installSpinner.start('Installing project dependencies with Bun...');
+            const installResult = spawnSync('bun', ['install'], { cwd: projectPath, stdio: 'ignore', shell: true });
+            if (installResult.status === 0) {
+                installSpinner.stop(chalk.green('Dependencies installed successfully!'));
+            }
+            else {
+                installSpinner.stop(chalk.yellow('Dependency installation finished with warnings.'));
+            }
+        }
         console.log(`${chalk.cyan('│')}`);
         console.log(`${chalk.cyan('│')}  ${chalk.white.bold('Next steps:')}`);
         console.log(`${chalk.cyan('│')}  ${chalk.dim('1.')} cd ${chalk.cyan(projectName)}`);
-        console.log(`${chalk.cyan('│')}  ${chalk.dim('2.')} bun install`);
-        console.log(`${chalk.cyan('│')}  ${chalk.dim('3.')} bun run build`);
+        if (!shouldInstall) {
+            console.log(`${chalk.cyan('│')}  ${chalk.dim('2.')} bun install`);
+            console.log(`${chalk.cyan('│')}  ${chalk.dim('3.')} bun run build`);
+        }
+        else {
+            console.log(`${chalk.cyan('│')}  ${chalk.dim('2.')} bun run build`);
+        }
         console.log(`${chalk.cyan('│')}`);
         outro(chalk.green.bold('Happy coding!'));
     }

package/lib/cli/main.d.ts

@@ -1,13 +1,34 @@
 import type { ProcessOptions } from './types';
 import { type InitOptions } from './init';
+import { type DoctorOptions } from './doctor';
+import { type CreateOptions } from './create';
+import { type HostOptions, type HostResult } from './host';
 export declare class KitCLI {
     /**
-     * Start resource builder.
+     * Start resource builder or watcher.
+     * @param pProcessOptions - Configuration options for resource processing.
      */
     static processResources(pProcessOptions: ProcessOptions): Promise<void>;
     /**
      * Start project initialization.
+     * @param pInitOptions - Configuration options for project initialization.
      */
     static init(pInitOptions: InitOptions): Promise<void>;
+    /**
+     * Run environment and project diagnostics.
+     * @param pDoctorOptions - Configuration options for diagnostics.
+     */
+    static doctor(pDoctorOptions?: DoctorOptions): Promise<boolean>;
+    /**
+     * Create boilerplate code (e.g. plugins).
+     * @param pCreateOptions - Configuration options for code generation.
+     */
+    static create(pCreateOptions: CreateOptions): Promise<void>;
+    /**
+     * Host game project locally.
+     * @param pHostOptions - Configuration options for hosting.
+     * @returns HostResult indicating status and server reference if applicable.
+     */
+    static host(pHostOptions?: HostOptions): Promise<HostResult>;
 }
 //# sourceMappingURL=main.d.ts.map

package/lib/cli/main.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"main.d.ts","sourceRoot":"","sources":["../../src/cli/main.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,SAAS,CAAC;AAE9C,OAAO,EAAe,KAAK,WAAW,EAAE,MAAM,QAAQ,CAAC;AAEvD,qBAAa,MAAM;IACf;;OAEG;WACU,gBAAgB,CAAC,eAAe,EAAE,cAAc,GAAG,OAAO,CAAC,IAAI,CAAC;IAI7E;;OAEG;WACU,IAAI,CAAC,YAAY,EAAE,WAAW,GAAG,OAAO,CAAC,IAAI,CAAC;CAG9D"}
+{"version":3,"file":"main.d.ts","sourceRoot":"","sources":["../../src/cli/main.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,SAAS,CAAC;AAE9C,OAAO,EAAe,KAAK,WAAW,EAAE,MAAM,QAAQ,CAAC;AACvD,OAAO,EAAiB,KAAK,aAAa,EAAE,MAAM,UAAU,CAAC;AAC7D,OAAO,EAAiB,KAAK,aAAa,EAAE,MAAM,UAAU,CAAC;AAC7D,OAAO,EAAe,KAAK,WAAW,EAAE,KAAK,UAAU,EAAE,MAAM,QAAQ,CAAC;AAExE,qBAAa,MAAM;IACf;;;OAGG;WACU,gBAAgB,CAAC,eAAe,EAAE,cAAc,GAAG,OAAO,CAAC,IAAI,CAAC;IAI7E;;;OAGG;WACU,IAAI,CAAC,YAAY,EAAE,WAAW,GAAG,OAAO,CAAC,IAAI,CAAC;IAI3D;;;OAGG;WACU,MAAM,CAAC,cAAc,GAAE,aAAkB,GAAG,OAAO,CAAC,OAAO,CAAC;IAIzE;;;OAGG;WACU,MAAM,CAAC,cAAc,EAAE,aAAa,GAAG,OAAO,CAAC,IAAI,CAAC;IAIjE;;;;OAIG;WACU,IAAI,CAAC,YAAY,GAAE,WAAgB,GAAG,OAAO,CAAC,UAAU,CAAC;CAGzE"}

package/lib/cli/main.js

@@ -1,16 +1,43 @@
 import { processResources } from './resource-builder';
 import { processInit } from './init';
+import { processDoctor } from './doctor';
+import { processCreate } from './create';
+import { processHost } from './host';
 export class KitCLI {
     /**
-     * Start resource builder.
+     * Start resource builder or watcher.
+     * @param pProcessOptions - Configuration options for resource processing.
      */
     static async processResources(pProcessOptions) {
         await processResources(pProcessOptions);
     }
     /**
      * Start project initialization.
+     * @param pInitOptions - Configuration options for project initialization.
      */
     static async init(pInitOptions) {
         await processInit(pInitOptions);
     }
+    /**
+     * Run environment and project diagnostics.
+     * @param pDoctorOptions - Configuration options for diagnostics.
+     */
+    static async doctor(pDoctorOptions = {}) {
+        return await processDoctor(pDoctorOptions);
+    }
+    /**
+     * Create boilerplate code (e.g. plugins).
+     * @param pCreateOptions - Configuration options for code generation.
+     */
+    static async create(pCreateOptions) {
+        await processCreate(pCreateOptions);
+    }
+    /**
+     * Host game project locally.
+     * @param pHostOptions - Configuration options for hosting.
+     * @returns HostResult indicating status and server reference if applicable.
+     */
+    static async host(pHostOptions = {}) {
+        return await processHost(pHostOptions);
+    }
 }