create-kubojs 3.36.3

package/README.md

@@ -0,0 +1,266 @@
+# Create kubojs CLI
+
+A modern CLI tool for scaffolding end-to-end type-safe TypeScript projects with best practices and customizable configurations
+
+![demo](https://cdn.jsdelivr.net/gh/amanvarshney01/kubojs@master/demo.gif)
+
+## Quick Start
+
+Run without installing globally:
+
+```bash
+# Using bun (recommended)
+bun create kubojs@latest
+
+# Using pnpm
+pnpm create kubojs@latest
+
+# Using npm
+npx create-kubojs@latest
+```
+
+Follow the prompts to configure your project or use the `--yes` flag for defaults.
+
+## Features
+
+| Category                 | Options                                                                                                                                                                                                                                                                                                                                                                                                                                   |
+| ------------------------ | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| **TypeScript**           | End-to-end type safety across all parts of your application                                                                                                                                                                                                                                                                                                                                                                               |
+| **Frontend**             | • React with TanStack Router<br>• React with React Router<br>• React with TanStack Start (SSR)<br>• Next.js<br>• SvelteKit<br>• Nuxt (Vue)<br>• SolidJS<br>• Astro<br>• React Native bare Expo<br>• React Native with NativeWind (via Expo)<br>• React Native with Unistyles (via Expo)<br>• None                                                                                                                                         |
+| **Backend**              | • Hono<br>• Express<br>• Elysia<br>• Fastify<br>• Self (fullstack inside the web app)<br>• Convex<br>• None                                                                                                                                                                                                                                                                                                                               |
+| **API Layer**            | • tRPC (type-safe APIs)<br>• oRPC (OpenAPI-compatible type-safe APIs)<br>• None                                                                                                                                                                                                                                                                                                                                                           |
+| **Runtime**              | • Bun<br>• Node.js<br>• Cloudflare Workers<br>• None                                                                                                                                                                                                                                                                                                                                                                                      |
+| **Database**             | • SQLite<br>• PostgreSQL<br>• MySQL<br>• MongoDB<br>• None                                                                                                                                                                                                                                                                                                                                                                                |
+| **ORM**                  | • Drizzle (TypeScript-first)<br>• Prisma (feature-rich)<br>• Mongoose (for MongoDB)<br>• None                                                                                                                                                                                                                                                                                                                                             |
+| **Database Setup**       | • Turso (SQLite)<br>• Cloudflare D1 (SQLite)<br>• Neon (PostgreSQL)<br>• Supabase (PostgreSQL)<br>• Prisma Postgres<br>• MongoDB Atlas<br>• None (manual setup)                                                                                                                                                                                                                                                                           |
+| **Authentication**       | • Better Auth<br>• Clerk                                                                                                                                                                                                                                                                                                                                                                                                                  |
+| **Styling**              | Tailwind CSS with a shared shadcn/ui package for React web apps                                                                                                                                                                                                                                                                                                                                                                           |
+| **Addons**               | • PWA support<br>• Tauri (desktop applications)<br>• Electrobun (lightweight desktop shell)<br>• Starlight and Fumadocs (documentation sites)<br>• Biome, Oxlint, Ultracite, or Vite+ (linting and formatting)<br>• Lefthook, Husky (Git hooks)<br>• evlog (request logging for server/fullstack backends)<br>• MCP, Skills (agent tooling)<br>• OpenTUI, WXT (platform extensions)<br>• Turborepo, Nx, or Vite+ (monorepo orchestration) |
+| **Examples**             | • Todo app<br>• AI Chat interface (using Vercel AI SDK)                                                                                                                                                                                                                                                                                                                                                                                   |
+| **Developer Experience** | • Automatic Git initialization<br>• Package manager choice (npm, pnpm, bun)<br>• Automatic dependency installation                                                                                                                                                                                                                                                                                                                        |
+
+## Usage
+
+```bash
+Usage: kubojs [project-directory] [options]
+
+Options:
+  -V, --version                   Output the version number
+  -y, --yes                       Use default configuration
+  --template <type>               Use a template (mern, pern, t3, uniwind, none)
+  --database <type>               Database type (none, sqlite, postgres, mysql, mongodb)
+  --orm <type>                    ORM type (none, drizzle, prisma, mongoose)
+  --dry-run                       Validate configuration without writing files
+  --auth <provider>               Authentication (better-auth, clerk, none)
+  --payments <provider>           Payments provider (none)
+  --frontend <types...>           Frontend types (tanstack-router, react-router, tanstack-start, next, nuxt, svelte, solid, astro, native-bare, native-uniwind, native-unistyles, none)
+  --addons <types...>             Additional addons (pwa, tauri, electrobun, starlight, biome, lefthook, husky, mcp, turborepo, nx, vite-plus, fumadocs, ultracite, oxlint, opentui, wxt, skills, evlog, none)
+  --examples <types...>           Examples to include (todo, ai, none)
+  --git                           Initialize git repository
+  --no-git                        Skip git initialization
+  --package-manager <pm>          Package manager (npm, pnpm, bun)
+  --install                       Install dependencies
+  --no-install                    Skip installing dependencies
+  --db-setup <setup>              Database setup (turso, d1, neon, supabase, prisma-postgres, planetscale, mongodb-atlas, docker, none)
+  --web-deploy <setup>            Web deployment (cloudflare, docker, vercel, none)
+  --server-deploy <setup>         Server deployment (cloudflare, docker, vercel, none)
+  --backend <framework>           Backend framework (hono, express, fastify, elysia, convex, self, none)
+  --runtime <runtime>             Runtime (bun, node, workers, none)
+  --api <type>                    API type (trpc, orpc, none)
+  --directory-conflict <strategy> Directory strategy (merge, overwrite, increment, error)
+  --manual-db                     Skip automatic database setup prompts
+  -h, --help                      Display help
+```
+
+### Agent-Focused Commands
+
+```bash
+# Raw JSON payload input (agent-friendly)
+kubojs create-json --input '{"projectName":"my-app","yes":true,"dryRun":true}'
+kubojs add-json --input '{"projectDir":"./my-app","addons":["wxt"],"addonOptions":{"wxt":{"template":"react"}}}'
+kubojs create-json --input '{"projectName":"db-app","database":"postgres","orm":"drizzle","dbSetup":"neon","dbSetupOptions":{"mode":"manual"}}'
+
+# Runtime schema/introspection output
+kubojs schema --name all
+kubojs schema --name createInput
+kubojs schema --name addInput
+kubojs schema --name addonOptions
+kubojs schema --name dbSetupOptions
+kubojs schema --name cli
+
+# Local stdio MCP server
+npx kubojs@latest mcp
+```
+
+To install kubojs into supported agent configs with `add-mcp` and avoid relying on a global CLI install:
+
+```bash
+npx -y add-mcp@latest "npx -y kubojs@latest mcp"
+```
+
+When you scaffold with the `mcp` addon, kubojs itself can also be installed into supported agent configs through `add-mcp` using a package runner command instead of assuming a global CLI install. For Bun projects, the generated config uses the equivalent `bunx kubojs@latest mcp` server command inside `add-mcp`.
+
+For MCP project creation, prefer `install: false`. Long dependency installs can exceed common MCP client request timeouts, so the safest flow is to scaffold first and run your package manager install command afterward in the project directory.
+
+## Telemetry
+
+This CLI collects anonymous usage data to help improve the tool. The data collected includes:
+
+- Configuration options selected
+- CLI version
+- Node.js version
+- Platform (OS)
+
+**Telemetry is enabled by default in published versions** to help us understand usage patterns and improve the tool.
+
+### Disabling Telemetry
+
+You can disable telemetry by setting the `BTS_TELEMETRY_DISABLED` environment variable:
+
+```bash
+# Disable telemetry for a single run
+BTS_TELEMETRY_DISABLED=1 npx kubojs
+
+# Disable telemetry globally in your shell profile (.bashrc, .zshrc, etc.)
+export BTS_TELEMETRY_DISABLED=1
+```
+
+## Examples
+
+Create a project with default configuration:
+
+```bash
+npx kubojs --yes
+```
+
+Validate a command without writing files:
+
+```bash
+npx kubojs --yes --dry-run
+```
+
+Create a project with specific options:
+
+```bash
+npx kubojs --database postgres --orm drizzle --auth better-auth --addons pwa biome
+```
+
+Create a project with Elysia backend and Node.js runtime:
+
+```bash
+npx kubojs --backend elysia --runtime node
+```
+
+Create a project with multiple frontend options (one web + one native):
+
+```bash
+npx kubojs --frontend tanstack-router native-bare
+```
+
+Create a project with examples:
+
+```bash
+npx kubojs --examples todo ai
+```
+
+Create a project with Turso database setup:
+
+```bash
+npx kubojs --database sqlite --orm drizzle --db-setup turso
+```
+
+Create a project with Supabase PostgreSQL setup:
+
+```bash
+npx kubojs --database postgres --orm drizzle --db-setup supabase --auth better-auth
+```
+
+Create a project with Convex backend:
+
+```bash
+npx kubojs --backend convex --frontend tanstack-router
+```
+
+Create a project with documentation site:
+
+```bash
+npx kubojs --addons starlight
+```
+
+Create a minimal TypeScript project with no backend:
+
+```bash
+npx kubojs --backend none --frontend tanstack-router
+```
+
+Create a backend-only project with no frontend:
+
+```bash
+npx kubojs --frontend none --backend hono --database postgres --orm drizzle
+```
+
+Create a simple frontend-only project:
+
+```bash
+npx kubojs --backend none --frontend next --addons none --examples none
+```
+
+Create a Cloudflare Workers project:
+
+```bash
+npx kubojs --backend hono --runtime workers --database sqlite --orm drizzle --db-setup d1
+```
+
+Create a self-hosted fullstack project on Cloudflare with D1:
+
+```bash
+npx kubojs --backend self --frontend next --api trpc --database sqlite --orm drizzle --db-setup d1 --web-deploy cloudflare
+```
+
+Create a self-hosted project that ships as Docker containers (web + server + database via Docker Compose):
+
+```bash
+npx kubojs --frontend tanstack-router --backend hono --runtime bun --database postgres --orm drizzle --db-setup docker --web-deploy docker --server-deploy docker
+```
+
+Create a minimal API-only project:
+
+```bash
+npx kubojs --frontend none --backend hono --api trpc --database none --addons none
+```
+
+## Compatibility Notes
+
+- **Convex backend**: Requires `database`, `orm`, `api`, `runtime`, and `server-deploy` to be `none`; auth can be `better-auth`, `clerk`, or `none` depending frontend compatibility
+- **Backend 'none'**: If selected, this option will force related options like API, ORM, database, authentication, and runtime to 'none'. Examples will also be disabled (set to none/empty).
+- **Frontend 'none'**: Creates a backend-only project. When selected, PWA, Tauri, Electrobun, and certain examples may be disabled.
+- **API 'none'**: Disables tRPC/oRPC setup. Can be used with backend frameworks for REST APIs or custom API implementations.
+- **Database 'none'**: Disables database setup and requires ORM to be `none`.
+- **ORM 'none'**: Can be used when you want to handle database operations manually or use a different ORM.
+- **Runtime 'none'**: Only available with Convex backend, backend `none`, or backend `self`.
+- **Cloudflare Workers runtime**: Only compatible with Hono backend. If a database is used, MongoDB is not supported.
+- **Cloudflare D1 setup**: Requires `sqlite` and either `--runtime workers --server-deploy cloudflare` or `--backend self --web-deploy cloudflare`. For `backend self`, D1 is supported on `next`, `tanstack-start`, `nuxt`, `svelte`, and `astro`.
+- **Addons 'none'**: Skips all addons.
+- **Examples 'none'**: Skips all example implementations (todo, AI chat).
+- **Nuxt, Svelte, SolidJS, and Astro** frontends are only compatible with oRPC API layer
+- **PWA support** requires TanStack Router, React Router, Next.js, or SolidJS
+- **Tauri desktop app** requires TanStack Router, React Router, TanStack Start, Next.js, Nuxt, SvelteKit, SolidJS, or Astro
+- **Electrobun desktop app** requires TanStack Router, React Router, TanStack Start, Next.js, Nuxt, SvelteKit, SolidJS, or Astro. Desktop packaging uses static web assets, so SSR-first frontends need a static/export build before desktop builds will work.
+- **AI example** is not compatible with Solid or Astro. With Convex backend, it also excludes Nuxt and Svelte.
+
+## Project Structure
+
+The created project follows a clean monorepo structure:
+
+```
+my-kubo-app/
+├── apps/
+│   ├── web/          # Frontend application
+│   ├── server/       # Backend API
+│   ├── native/       # (optional) Mobile application
+│   └── docs/         # (optional) Documentation site
+├── packages/         # Shared packages
+└── README.md         # Auto-generated project documentation
+```
+
+After project creation, you'll receive detailed instructions for next steps and additional setup requirements.

package/dist/chunk-BtN16TXe.mjs

@@ -0,0 +1,28 @@
+#!/usr/bin/env node
+//#region \0rolldown/runtime.js
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __exportAll = (all, no_symbols) => {
+	let target = {};
+	for (var name in all) __defProp(target, name, {
+		get: all[name],
+		enumerable: true
+	});
+	if (!no_symbols) __defProp(target, Symbol.toStringTag, { value: "Module" });
+	return target;
+};
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+//#endregion
+export { __reExport as n, __exportAll as t };

package/dist/cli.d.mts

@@ -0,0 +1 @@
+export { };

package/dist/cli.mjs

@@ -0,0 +1,293 @@
+#!/usr/bin/env node
+import { _ as types_exports, i as SchemaNameSchema, l as create, m as getSchemaResult, s as add, u as createBtsCli, v as getLatestCLIVersion } from "./src-BpWey5Sf.mjs";
+import z from "zod";
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+//#region src/mcp.ts
+const ToolResponseSchema = z.object({
+	ok: z.boolean(),
+	data: z.any().optional(),
+	error: z.string().optional()
+});
+const SchemaToolInputSchema = z.object({ name: SchemaNameSchema.optional().describe("Schema name to inspect. Defaults to all.") });
+const McpCreateProjectInputSchema = types_exports.CreateInputSchema.safeExtend({
+	projectName: z.string().describe("Project name or relative path"),
+	frontend: z.array(types_exports.FrontendSchema).describe("Explicit frontend app surfaces. Do not use native frontends as styling options."),
+	backend: types_exports.BackendSchema.describe("Explicit backend framework"),
+	runtime: types_exports.RuntimeSchema.describe("Explicit runtime environment"),
+	database: types_exports.DatabaseSchema.describe("Explicit database choice"),
+	orm: types_exports.ORMSchema.describe("Explicit ORM choice"),
+	api: types_exports.APISchema.describe("Explicit API layer"),
+	auth: types_exports.AuthSchema.describe("Explicit authentication provider"),
+	payments: types_exports.PaymentsSchema.describe("Explicit payments provider"),
+	addons: z.array(types_exports.AddonsSchema).describe("Explicit addon list. Use [] when no addons are needed."),
+	examples: z.array(types_exports.ExamplesSchema).describe("Explicit example list. Use [] when no examples are needed."),
+	git: z.boolean().describe("Whether to initialize a git repository"),
+	packageManager: types_exports.PackageManagerSchema.describe("Explicit package manager"),
+	install: z.boolean().describe("Whether to install dependencies"),
+	dbSetup: types_exports.DatabaseSetupSchema.describe("Explicit database setup/provisioning choice"),
+	webDeploy: types_exports.WebDeploySchema.describe("Explicit web deployment choice"),
+	serverDeploy: types_exports.ServerDeploySchema.describe("Explicit server deployment choice"),
+	addonOptions: types_exports.AddonOptionsSchema.optional(),
+	dbSetupOptions: types_exports.DbSetupOptionsSchema.optional(),
+	directoryConflict: types_exports.DirectoryConflictSchema.optional()
+}).describe("Explicit I dont know project configuration for MCP use. Provide the full stack config instead of relying on inferred defaults.");
+function formatToolSuccess(data) {
+	return {
+		content: [{
+			type: "text",
+			text: JSON.stringify(data, null, 2)
+		}],
+		structuredContent: {
+			ok: true,
+			data
+		}
+	};
+}
+function formatToolError(error) {
+	const message = error instanceof Error ? error.message : String(error);
+	return {
+		content: [{
+			type: "text",
+			text: message
+		}],
+		structuredContent: {
+			ok: false,
+			error: message
+		},
+		isError: true
+	};
+}
+function getProjectToolAnnotations() {
+	return {
+		destructiveHint: true,
+		idempotentHint: false,
+		openWorldHint: true
+	};
+}
+function getMcpInstallTimeoutMessage(packageManager) {
+	return [
+		"MCP project creation requires `install: false`.",
+		"Dependency installation can exceed common MCP client request timeouts and cause the connection to close before the tool returns.",
+		`Scaffold the project first, then run \`${packageManager} install\` in the generated project directory from a terminal.`
+	].join(" ");
+}
+function getStackGuidance() {
+	return {
+		workflow: [
+			"Call bts_get_schema or bts_get_stack_guidance before constructing a config if the request is ambiguous.",
+			"For project creation, build a full explicit config before calling bts_plan_project.",
+			"Always call bts_plan_project before bts_create_project.",
+			"Only call bts_create_project after the plan succeeds and matches the user's intent.",
+			"Use bts_plan_addons before bts_add_addons for existing projects."
+		],
+		createContract: {
+			requiresExplicitFields: [
+				"projectName",
+				"frontend",
+				"backend",
+				"runtime",
+				"database",
+				"orm",
+				"api",
+				"auth",
+				"payments",
+				"addons",
+				"examples",
+				"git",
+				"packageManager",
+				"install",
+				"dbSetup",
+				"webDeploy",
+				"serverDeploy"
+			],
+			optionalFields: [
+				"addonOptions",
+				"dbSetupOptions",
+				"directoryConflict"
+			],
+			rule: "Do not call bts_plan_project or bts_create_project with a partial payload. MCP project creation requires the full explicit stack config."
+		},
+		fieldNotes: {
+			frontend: "frontend is for app surfaces only. Choose explicit app targets such as next, react-router, tanstack-router, native-bare, native-uniwind, or native-unistyles.",
+			addons: "addons must be an explicit array. Use [] when no addons are requested.",
+			examples: "examples must be an explicit array. Use [] when no examples are requested.",
+			dbSetup: "dbSetup is always required. Use 'none' when no managed database provisioning is requested.",
+			webDeploy: "webDeploy is always required. Use 'none' when no web deployment target is requested.",
+			serverDeploy: "serverDeploy is always required. Use 'none' when no server deployment target is requested.",
+			packageManager: "packageManager is always required because installation and reproducible commands depend on it.",
+			install: "install is always required. For MCP project creation, prefer false because many clients enforce request timeouts around long-running dependency installs.",
+			git: "git is always required. Set it to true or false explicitly instead of relying on defaults."
+		},
+		ambiguityRules: [
+			"If the user request leaves major stack choices unspecified, stop and resolve them before calling bts_plan_project.",
+			"Do not infer extra app surfaces, addons, examples, or provisioning choices from a template name or styling preference.",
+			"If the user wants the smallest valid stack, still send the full config with explicit 'none', [] , true, or false values where appropriate.",
+			"For MCP execution, scaffold with install=false and let the user or agent run dependency installation separately from a terminal session."
+		]
+	};
+}
+function createBtsMcpServer() {
+	const server = new McpServer({
+		name: "kubojs",
+		version: getLatestCLIVersion()
+	}, { capabilities: { logging: {} } });
+	server.registerTool("bts_get_stack_guidance", {
+		title: "Get I dont know MCP Guidance",
+		description: "Read MCP-specific guidance for choosing valid I dont know configurations. Use this before planning when user intent is ambiguous. This explains the full explicit config required by MCP project creation, plus important field semantics and ambiguity rules.",
+		outputSchema: ToolResponseSchema,
+		annotations: {
+			title: "Get I dont know MCP Guidance",
+			readOnlyHint: true,
+			destructiveHint: false,
+			idempotentHint: true,
+			openWorldHint: false
+		}
+	}, async () => {
+		try {
+			return formatToolSuccess(getStackGuidance());
+		} catch (error) {
+			return formatToolError(error);
+		}
+	});
+	server.registerTool("bts_get_schema", {
+		title: "Get I dont know Schemas",
+		description: "Inspect I dont know CLI and input schemas so agents can plan valid create/add requests. Use this together with bts_get_stack_guidance before creating a project if any part of the request is ambiguous.",
+		inputSchema: SchemaToolInputSchema,
+		outputSchema: ToolResponseSchema,
+		annotations: {
+			title: "Get I dont know Schemas",
+			readOnlyHint: true,
+			destructiveHint: false,
+			idempotentHint: true,
+			openWorldHint: false
+		}
+	}, async ({ name }) => {
+		try {
+			return formatToolSuccess(getSchemaResult(name ?? "all"));
+		} catch (error) {
+			return formatToolError(error);
+		}
+	});
+	server.registerTool("bts_plan_project", {
+		title: "Plan I dont know Project",
+		description: "Validate and preview an I dont know project creation without writing files or provisioning resources. Always use this before bts_create_project. This tool requires an explicit full stack config rather than a partial payload with inferred defaults.",
+		inputSchema: McpCreateProjectInputSchema,
+		outputSchema: ToolResponseSchema,
+		annotations: {
+			title: "Plan I dont know Project",
+			readOnlyHint: true,
+			destructiveHint: false,
+			idempotentHint: true,
+			openWorldHint: false
+		}
+	}, async (input) => {
+		try {
+			const result = await create(input.projectName, {
+				...input,
+				dryRun: true,
+				disableAnalytics: true
+			});
+			if (result.isErr()) return formatToolError(result.error);
+			return formatToolSuccess(input.install ? {
+				...result.value,
+				warnings: [getMcpInstallTimeoutMessage(input.packageManager)],
+				recommendedMcpExecution: {
+					...input,
+					install: false
+				}
+			} : result.value);
+		} catch (error) {
+			return formatToolError(error);
+		}
+	});
+	server.registerTool("bts_create_project", {
+		title: "Create I dont know Project",
+		description: "Create an I dont know project on disk using the same silent programmatic flow as the CLI JSON API. Call this only after bts_plan_project succeeds and the plan clearly matches the user's intent. This tool requires an explicit full stack config.",
+		inputSchema: McpCreateProjectInputSchema,
+		outputSchema: ToolResponseSchema,
+		annotations: {
+			title: "Create I dont know Project",
+			...getProjectToolAnnotations()
+		}
+	}, async (input) => {
+		try {
+			if (input.install) return formatToolError(getMcpInstallTimeoutMessage(input.packageManager));
+			const result = await create(input.projectName, {
+				...input,
+				disableAnalytics: true
+			});
+			if (result.isErr()) return formatToolError(result.error);
+			return formatToolSuccess(result.value);
+		} catch (error) {
+			return formatToolError(error);
+		}
+	});
+	server.registerTool("bts_plan_addons", {
+		title: "Plan I dont know Addons",
+		description: "Validate and preview addon installation for an existing I dont know project without writing files. Always use this before bts_add_addons when the addon set or nested options are uncertain.",
+		inputSchema: types_exports.AddInputSchema,
+		outputSchema: ToolResponseSchema,
+		annotations: {
+			title: "Plan I dont know Addons",
+			readOnlyHint: true,
+			destructiveHint: false,
+			idempotentHint: true,
+			openWorldHint: false
+		}
+	}, async (input) => {
+		try {
+			const result = await add({
+				...input,
+				dryRun: true
+			});
+			if (!result?.success) return formatToolError(result?.error ?? "Failed to plan addon installation");
+			return formatToolSuccess(result);
+		} catch (error) {
+			return formatToolError(error);
+		}
+	});
+	server.registerTool("bts_add_addons", {
+		title: "Add I dont know Addons",
+		description: "Install addons into an existing I dont know project using the same silent flow as add-json. Call this only after bts_plan_addons succeeds and the planned changes match the user's intent.",
+		inputSchema: types_exports.AddInputSchema,
+		outputSchema: ToolResponseSchema,
+		annotations: {
+			title: "Add I dont know Addons",
+			destructiveHint: true,
+			idempotentHint: false,
+			openWorldHint: true
+		}
+	}, async (input) => {
+		try {
+			const result = await add(input);
+			if (!result?.success) return formatToolError(result?.error ?? "Failed to add addons");
+			return formatToolSuccess(result);
+		} catch (error) {
+			return formatToolError(error);
+		}
+	});
+	return server;
+}
+async function startBtsMcpServer() {
+	const server = createBtsMcpServer();
+	const transport = new StdioServerTransport();
+	await server.connect(transport);
+}
+//#endregion
+//#region src/cli.ts
+const [, , command, ...args] = process.argv;
+if (command === "mcp") {
+	if (args.includes("--help") || args.includes("-h")) {
+		console.log(`Usage: kubojs mcp
+
+Start the I dont know MCP server over stdio.
+
+This command is intended to be launched by an MCP client, for example:
+  kubojs mcp`);
+		process.exit(0);
+	}
+	await startBtsMcpServer();
+} else await createBtsCli().run();
+//#endregion
+export {};