create-cmp-cli 0.2.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Karel van der Merwe and create-cmp contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,232 @@
+<div align="center">
+
+# create-cmp
+
+**Scaffold a green-building Kotlin/Compose Multiplatform app (Android + iOS) in minutes — not hours.**
+
+Toolchain auto-bootstrapped · Navigation & insets pre-solved · Clean Architecture wired · Appium harness ready.
+
+[![CI](https://github.com/kvdm-co-pilot/create-cmp/actions/workflows/ci.yml/badge.svg)](https://github.com/kvdm-co-pilot/create-cmp/actions/workflows/ci.yml)
+[![License: MIT](https://img.shields.io/badge/license-MIT-green.svg)](./LICENSE)
+[![PRs welcome](https://img.shields.io/badge/PRs-welcome-brightgreen.svg)](./CONTRIBUTING.md)
+[![Kotlin Multiplatform](https://img.shields.io/badge/Kotlin-Multiplatform-7F52FF.svg?logo=kotlin&logoColor=white)](https://kotlinlang.org/docs/multiplatform.html)
+[![Claude Code plugin](https://img.shields.io/badge/Claude%20Code-plugin-D97757.svg)](#use-it-from-claude-code)
+
+</div>
+
+---
+
+Starting a Compose Multiplatform project is slow and flaky — not because the knowledge is hard, but
+because it isn't *reproducible*. Kotlin ↔ KSP ↔ CMP ↔ Room ↔ AGP must all agree or the build dies;
+the iOS shell (XcodeGen + CocoaPods + Firebase pods + AppDelegate + framework embedding) is a
+multi-step minefield; edge-to-edge insets get re-debugged on every project; and the toolchain itself
+is a cliff most scaffolders leave to you. That friction is why greenfield mobile apps quietly default
+to React Native.
+
+**`create-cmp` removes the friction.** It *stamps* a frozen, CI-verified golden template (it does not
+freehand-generate your project), bootstraps the toolchain, and **proves a green build** before it
+reports success.
+
+## Contents
+
+- [Quick start](#quick-start)
+- [Commands](#commands)
+- [What you get](#what-you-get-the-pre-solved-moat)
+- [Options](#options)
+- [Use it from Claude Code](#use-it-from-claude-code)
+- [Why CMP, not React Native](#why-cmp-not-react-native)
+- [How it works](#how-it-works)
+- [Requirements](#requirements)
+- [Roadmap](#roadmap)
+- [Contributing](#contributing)
+
+> **Full usage in one place:** [`docs/USAGE.md`](./docs/USAGE.md) is the single entry point — setup,
+> every CLI command, all 8 skills, the 14-tool `cmp-inspector` MCP, and the workflows that tie them
+> together. Read it and you can drive create-cmp end to end (agents included).
+
+## Quick start
+
+```bash
+npx create-cmp-cli@latest
+```
+
+…or non-interactively:
+
+```bash
+npx create-cmp-cli@latest --name Acme --package com.acme.app --yes --verify
+```
+
+The scaffolder interviews you (or takes flags), runs the toolchain doctor, stamps the template, and
+builds the app to prove it's green.
+
+> **On the package name:** it publishes as `create-cmp-cli` — the bare name `create-cmp` is held by
+> an unrelated placeholder, and `create-cmp-app` is a real, unrelated CMP generator, so we didn't
+> reuse either. The installed *command* is still `create-cmp`. You can also run straight from GitHub
+> with no install: `npx github:kvdm-co-pilot/create-cmp`, or use the
+> [Claude Code plugin](#use-it-from-claude-code).
+
+## Commands
+
+`create-cmp` is useful across the whole life of a project, not just day one — and every command
+except `create` works on **any** KMP project, not only ones it scaffolded:
+
+| Command | What it does |
+|---|---|
+| `create-cmp [dir]` / `create-cmp create` | Scaffold a new app from the frozen golden template (the default command). |
+| `create-cmp doctor [--fix]` | Toolchain preflight (JDK/SDK/Xcode/Appium, consent-gated installs) **plus** project diagnosis when run inside a Gradle project: kotlin↔ksp lockstep, drift vs proven-green sets, the KSP2/iOS catch-22, sdk.dir, `~/.konan` bloat, disk space. `--fix` applies the safe heals. |
+| `create-cmp upgrade [--dry-run]` | Migrate `gradle/libs.versions.toml` to the next proven-green version set — diff table first, surgical in-place edits with `.bak-upgrade` backups, kotlin↔ksp lockstep guardrail, `--verify` to prove the result. |
+| `create-cmp clean` | Cache & build-output hygiene: stale `~/.konan` toolchains + project `build/`/`.gradle/` dirs (sizes shown, consent-gated); `~/.gradle/caches` is size-reported only. |
+| `create-cmp verify [--target-dir .]` | Run the green-build gate (Android, and iOS on macOS) against an existing project. |
+
+> **North-star (a goal, measured honestly — not a benchmark):** *time-to-green* — a running app on
+> the Android emulator **and** the iOS simulator, smoke-passing, with zero manual steps modulo the
+> one Xcode App Store install. Target: **under 5 minutes on a clean machine.** Every scaffold ends
+> with a `--verify` build gate, so success is *proven*, not assumed.
+
+## What you get (the pre-solved moat)
+
+Everything below is **stamped from a template that builds green on Android + iOS** — not regenerated
+per run, so it can't silently drift:
+
+- **A pinned, version-locked dependency set** — Kotlin, KSP, Compose Multiplatform, Room, AGP, Koin,
+  Ktor, GitLive Firebase KMP, Navigation Compose, Lifecycle — chosen to actually agree with each
+  other, including the iOS Room/KSP2 catch-22 (`ksp.useKSP2=true`). Frozen and CI-gated.
+- **The iOS shell, in the order that builds** — `project.yml` (XcodeGen), `Podfile` (Firebase static
+  linkage), `Info.plist`, `iOSApp.swift` (AppDelegate + `FirebaseApp.configure()` before Koin),
+  `ContentView.swift` (ComposeUIViewController bridge).
+- **The Android shell** — `AndroidManifest`, `MainActivity` with `enableEdgeToEdge()`, `Application`
+  starting Koin + Room, adaptive-icon structure.
+- **Navigation + insets, solved once** — a generic `BaseScreen` Scaffold owning window insets /
+  status- and nav-bar padding, plus a data-driven `AppShell` + bottom nav fed by your `tabs` list
+  (not role-hardcoded), with type-safe routes.
+- **Clean Architecture, wired** — `core / data{local,remote} / domain{model,repository,usecase} /
+  presentation{components,theme,navigation,<feature>} / di` with Koin modules registered and **one
+  example feature wired end-to-end** as the copy-paste pattern.
+- **Theme & tokens** — `<Prefix>Theme`, `<Prefix>Tokens`, `<Prefix>Colors`, DM Sans.
+- **An Appium harness** — an Appium client + smoke runner and a sample smoke asserting the bottom nav
+  renders, so "done" can be proven on a device.
+- **A toolchain doctor** — diagnoses *and* heals JDK, Android SDK + AVD, Xcode/CLT, CocoaPods,
+  XcodeGen, Appium + drivers, Node. Idempotent, OS-aware, consent-gated.
+- **AI-inspectable by default** — every generated app ships a debug-only live inspector
+  (`127.0.0.1:9500`, loopback, structurally absent from release). An agent runs `connect_live` and
+  reads the running UI as JSON — hierarchy, geometry, resolved design tokens, real navigation
+  state. Never screenshots. Toggle with `--no-inspector`; `create-cmp doctor` verifies it stays
+  debug-only and that every declared theme token is served on `/inspect/design-system`.
+- **Live device view** — with the debug app running, open `http://127.0.0.1:9500/inspect/remote`
+  (after `adb forward tcp:9500 tcp:9500`) to watch the real device and click the image to tap it,
+  while the agent drives `navigate_and_inspect` on the semantics tree and proves every change with
+  `prove_change`. Pixels for the human, structure for the AI.
+- **Desktop dev-client** — a phone-sized JVM window running the shared UI with Compose Hot Reload
+  attached (`./gradlew :composeApp:hotRunDesktop --auto`); Firebase never initializes on desktop
+  (offline DI fakes). Toggle with `--no-dev-client`.
+
+`google-services.json` / `GoogleService-Info.plist` are intentionally **not** real — you get
+placeholders and clear "drop your Firebase config here" instructions.
+
+## Options
+
+| Option | Choices | Default |
+|---|---|---|
+| Platforms | Android (always) + iOS | iOS on |
+| App name / package / iOS bundle id | — | required / derived |
+| Firebase region | any Firebase region | `us-central1` |
+| Firebase (GitLive KMP) | on / off | on |
+| Auth | `email` / `phone` / `both` / `none` | `both` |
+| Firebase services | Firestore · Storage · Functions · FCM | all on |
+| Room local cache | on / off | on |
+| Appium harness | on / off | on |
+| Bottom-nav tabs | label + icon, any count | Home, Profile |
+
+_(Web/PWA is intentionally out of scope — Android + iOS only.)_
+
+## Use it from Claude Code
+
+`create-cmp` also ships as a [Claude Code](https://docs.claude.com/en/docs/claude-code) plugin — one
+shared engine, two front doors. Install from the bundled marketplace:
+
+```text
+/plugin marketplace add kvdm-co-pilot/create-cmp
+/plugin install create-cmp
+```
+
+It bundles eight skills (plus the `cmp-inspector` MCP server), each with a deterministic engine
+behind it:
+
+- **cmp-new** — conversational interview, then shells out to the same engine to scaffold, and
+  generates your tab screens from the example-feature pattern.
+- **cmp-doctor** — toolchain bootstrap + project diagnosis on any KMP project (consent-gated).
+- **cmp-upgrade** — migrate to the next proven-green version set (diff → apply → verify).
+- **cmp-inspect** — see and drive a rendered Compose UI as structured JSON: hierarchy, geometry,
+  resolved design tokens, drift diffs, golden-tree snapshots, a11y audit, live navigation
+  (`navigate_and_inspect`), wireframe rendering, and `prove_change` — the verified dev loop.
+- **cmp-dev-client** — run the shared UI in a phone-sized desktop window with Compose Hot Reload
+  (`./gradlew :composeApp:hotRunDesktop --auto`) — the Expo-style dev loop for KMP.
+- **cmp-firebase-connect** — post-scaffold onboarding: create/reuse a Firebase project, register
+  the app, and replace the placeholder config via the Firebase CLI (consent-gated), proven by a
+  green build.
+- **cmp-test** — generate the Appium regression suite by *observing* the app: read the running
+  UI's semantics tree and emit tests in the shipped harness style.
+- **cmp-qa-prep** — brings up the emulator + Appium session + smoke.
+
+## Why CMP, not React Native
+
+This isn't a knock on React Native — it's about defaults. The only place CMP loses to RN on a new
+app is **time-to-first-green-build**, and that's a tooling problem, not a merits problem. With
+`create-cmp`, CMP's `npx`-and-go is competitive:
+
+- **One language, real native UI.** Kotlin shared logic *and* Compose UI across Android and iOS — no
+  JS bridge, no separate native-module dance for the common case.
+- **Native performance and platform access** without the RN bridge tax.
+- **Reproducible by construction.** A frozen, version-locked, CI-gated template means the build that
+  was green yesterday is green today — the exact property ad-hoc CMP setups lack.
+- **Proven, not assumed.** Every scaffold ends on a real build (and an Appium smoke), with a
+  GREEN/FAIL verdict.
+
+If `create-next-app` made React the default for the web by removing setup friction, the goal here is
+the same for multiplatform mobile.
+
+## How it works
+
+```
+Front doors:  npx create-cmp-cli   +   Claude Code plugin (cmp-new / cmp-doctor / cmp-qa-prep)
+                                  │  one shared engine, two front doors
+Engine (Node, deterministic):     copy → token-replace → rename packages → toggle features → VERIFY
+Golden template (frozen, CI'd):   pinned versions · iOS shell · nav+insets · Clean Arch · DI · Appium
+```
+
+The engine never puts an LLM in the hot path: it copies the template, replaces placeholders in file
+contents *and* paths, atomically renames package directories, toggles features (Firebase / auth type
+/ Room / Appium), and runs the verify build. Determinism is the moat. See
+[`docs/ARCHITECTURE.md`](./docs/ARCHITECTURE.md) for the full design.
+
+## Requirements
+
+- **Node.js ≥ 18** to run the scaffolder.
+- **macOS** for iOS output (Xcode, CocoaPods, XcodeGen). Android output works on macOS or Linux.
+- Everything else — JDK 17, Android SDK + emulator, CocoaPods, XcodeGen, Appium + drivers — the
+  built-in `doctor` detects and (with your consent) installs. Xcode itself must be installed from the
+  App Store; the doctor surfaces that as the one manual step.
+
+## Roadmap
+
+The full plan — six pillars from scaffold to store release, and the sequencing — lives in
+[`docs/ROADMAP.md`](./docs/ROADMAP.md). Near-term:
+
+- [ ] Publish to npm as `create-cmp-cli` (`npx create-cmp-cli`) — release cut, publish pending.
+- [ ] Record the asciinema demo (`npx create-cmp-cli` → green Android + iOS).
+- [ ] Full Android + iOS build matrix in CI (currently CI runs the engine unit tests).
+- [ ] More example features and nav shapes.
+- **AI-native Compose inspector** — read a running app's hierarchy, geometry, and *resolved design
+  tokens* as structured JSON (no screenshots). **Phase 0 (headless host-JVM render → inspect) is
+  built and verified**; live-emulator inspection is next. See
+  [`docs/INSPECTOR-PLAN.md`](./docs/INSPECTOR-PLAN.md).
+
+## Contributing
+
+Issues and PRs welcome — see [CONTRIBUTING.md](./CONTRIBUTING.md) and our
+[Code of Conduct](./CODE_OF_CONDUCT.md). The golden template is CI-gated: an upstream version bump
+must fail CI, not your generated project.
+
+## License
+
+[MIT](./LICENSE) © Karel van der Merwe and create-cmp contributors.

package/bin/create-cmp.mjs

@@ -0,0 +1,91 @@
+#!/usr/bin/env node
+// create-cmp — scaffold and maintain production-ready Kotlin/Compose
+// Multiplatform apps.
+//
+// Thin subcommand dispatcher; each command lives in src/commands/<name>.mjs
+// and the deterministic engine in src/. Two front doors (this CLI + the
+// Claude Code plugin) share that one engine.
+//
+//   npx create-cmp [target-dir] [flags]        # scaffold (default command)
+//   npx create-cmp create  [target-dir] [flags]
+//   npx create-cmp doctor  [flags]             # toolchain + project diagnosis
+//   npx create-cmp upgrade [flags]             # migrate to a proven-green version set
+//   npx create-cmp clean   [flags]             # konan/Gradle cache & build-output hygiene
+//   npx create-cmp verify  [flags]             # green-build gate on an existing project
+
+import { parseArgs } from "../src/lib/args.mjs";
+
+const COMMANDS = new Set(["create", "doctor", "upgrade", "clean", "verify", "help"]);
+
+async function main() {
+  const argv = process.argv.slice(2);
+  const { _: positionals, flags } = parseArgs(argv);
+
+  // Backward compatible dispatch: the first positional is a subcommand only if
+  // it names one; otherwise it is the scaffold target dir (bare `create-cmp`
+  // and all pre-router invocations keep working exactly as before).
+  const command = COMMANDS.has(positionals[0]) ? positionals[0] : "create";
+  const rest = COMMANDS.has(positionals[0]) ? positionals.slice(1) : positionals;
+
+  if (flags.help || flags.h || command === "help") {
+    printHelp();
+    process.exit(0);
+  }
+
+  switch (command) {
+    case "doctor": {
+      const { runDoctor } = await import("../src/commands/doctor.mjs");
+      await runDoctor(flags, rest[0]);
+      return;
+    }
+    case "upgrade": {
+      const { runUpgrade } = await import("../src/commands/upgrade.mjs");
+      await runUpgrade(flags, rest[0]);
+      return;
+    }
+    case "clean": {
+      const { runClean } = await import("../src/commands/clean.mjs");
+      await runClean(flags, rest[0]);
+      return;
+    }
+    case "verify": {
+      const { runVerifyCommand } = await import("../src/commands/verify.mjs");
+      await runVerifyCommand(flags, rest[0]);
+      return;
+    }
+    case "create":
+    default: {
+      const { runCreate } = await import("../src/commands/create.mjs");
+      await runCreate(flags, rest[0]);
+    }
+  }
+}
+
+function printHelp() {
+  process.stdout.write(
+    `create-cmp — scaffold & maintain Kotlin/Compose Multiplatform apps (Android + iOS)\n\n` +
+      `Usage:\n` +
+      `  npx create-cmp [target-dir] [flags]    scaffold a new app (default command)\n` +
+      `  npx create-cmp create [target-dir]     same, explicit\n` +
+      `  npx create-cmp doctor                  toolchain doctor + project diagnosis (any KMP project)\n` +
+      `  npx create-cmp upgrade                 migrate to the next proven-green version set\n` +
+      `  npx create-cmp clean                   ~/.konan + Gradle build-output hygiene (consent-gated)\n` +
+      `  npx create-cmp verify                  run the green-build gate on an existing project\n\n` +
+      `create (scaffold) flags:\n` +
+      `  --name --package --bundle-id --region --theme-prefix\n` +
+      `  --ios/--no-ios  --firebase/--no-firebase  --auth <email|phone|both|none>\n` +
+      `  --room/--no-room  --appium/--no-appium  --inspector/--no-inspector\n` +
+      `  --dev-client/--no-dev-client   (desktop JVM window + Compose Hot Reload)\n` +
+      `  --tabs Home:home,Profile:person\n` +
+      `  --target-dir  --verify/--no-verify  --yes  --force  --dry-run-verify\n\n` +
+      `doctor flags:  --yes  --dry-run  --no-ios  --no-install  --target-dir <dir>  --fix\n` +
+      `upgrade flags: --target-dir <dir>  --set <id>  --dry-run  --yes  --verify\n` +
+      `clean flags:   --target-dir <dir>  --dry-run  --yes\n` +
+      `verify flags:  --target-dir <dir>  --no-ios  --dry-run\n`
+  );
+}
+
+main().catch((err) => {
+  process.stderr.write(`Fatal: ${err && err.stack ? err.stack : err}\n`);
+  process.exit(1);
+});

package/options.schema.json

@@ -0,0 +1,110 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "$id": "https://github.com/create-cmp/create-cmp/options.schema.json",
+  "title": "create-cmp engine config",
+  "description": "The config object built by the CLI/plugin front door and consumed by the scaffold engine.",
+  "type": "object",
+  "additionalProperties": false,
+  "required": [
+    "appName",
+    "package",
+    "iosBundleId",
+    "region",
+    "themePrefix",
+    "platforms",
+    "firebase",
+    "room",
+    "appium",
+    "inspector",
+    "devClient",
+    "tabs",
+    "targetDir"
+  ],
+  "properties": {
+    "appName": {
+      "type": "string",
+      "description": "Human display name.",
+      "minLength": 1,
+      "pattern": "^[^\\n\\r]+$"
+    },
+    "package": {
+      "type": "string",
+      "description": "Reverse-DNS package id, e.g. com.acme.app.",
+      "pattern": "^[a-z][a-z0-9_]*(\\.[a-z][a-z0-9_]*)+$"
+    },
+    "iosBundleId": {
+      "type": "string",
+      "description": "iOS bundle id, e.g. com.acme.app.",
+      "pattern": "^[A-Za-z0-9][A-Za-z0-9-]*(\\.[A-Za-z0-9][A-Za-z0-9-]*)+$"
+    },
+    "region": {
+      "type": "string",
+      "description": "Firebase region, e.g. us-central1.",
+      "minLength": 1,
+      "pattern": "^[a-z]+(-[a-z]+[0-9]+)?$|^[a-z-]+[0-9]+$"
+    },
+    "themePrefix": {
+      "type": "string",
+      "description": "PascalCase theme symbol prefix, e.g. Acme.",
+      "pattern": "^[A-Z][A-Za-z0-9]*$"
+    },
+    "platforms": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": ["android", "ios"],
+      "properties": {
+        "android": {
+          "type": "boolean",
+          "const": true,
+          "description": "Android is always enabled."
+        },
+        "ios": { "type": "boolean" }
+      }
+    },
+    "firebase": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": ["enabled"],
+      "properties": {
+        "enabled": { "type": "boolean" },
+        "auth": {
+          "type": "string",
+          "enum": ["email", "phone", "both", "none"]
+        },
+        "firestore": { "type": "boolean" },
+        "storage": { "type": "boolean" },
+        "functions": { "type": "boolean" },
+        "fcm": { "type": "boolean" }
+      }
+    },
+    "room": { "type": "boolean" },
+    "appium": { "type": "boolean" },
+    "inspector": {
+      "type": "boolean",
+      "description": "Live on-device inspector: debug-only loopback HTTP server (127.0.0.1:9500) serving the Compose semantics tree + design-token catalog to the cmp-inspector MCP. Structurally absent from release builds."
+    },
+    "devClient": {
+      "type": "boolean",
+      "description": "Desktop dev-client: a jvm(\"desktop\") target running the shared commonMain UI in a phone-sized JVM window with Compose Hot Reload attached (./gradlew :composeApp:hotRunDesktop --auto). Firebase is never initialized on desktop; platform seams get JVM fakes/impls in desktopMain."
+    },
+    "tabs": {
+      "type": "array",
+      "minItems": 1,
+      "maxItems": 5,
+      "items": {
+        "type": "object",
+        "additionalProperties": false,
+        "required": ["label", "icon"],
+        "properties": {
+          "label": { "type": "string", "minLength": 1 },
+          "icon": { "type": "string", "minLength": 1 }
+        }
+      }
+    },
+    "targetDir": {
+      "type": "string",
+      "description": "Destination directory for the stamped project.",
+      "minLength": 1
+    }
+  }
+}

package/package.json

@@ -0,0 +1,52 @@
+{
+  "name": "create-cmp-cli",
+  "version": "0.2.0",
+  "description": "Scaffold a production-ready Kotlin/Compose Multiplatform app (Android + iOS) that builds green in minutes — toolchain auto-bootstrapped, navigation/insets pre-solved, Clean Architecture wired, Appium harness ready. Installs the `create-cmp` command.",
+  "type": "module",
+  "bin": {
+    "create-cmp": "bin/create-cmp.mjs",
+    "create-cmp-cli": "bin/create-cmp.mjs"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "files": [
+    "bin",
+    "src",
+    "template",
+    "options.schema.json"
+  ],
+  "scripts": {
+    "test": "node --test",
+    "prepublishOnly": "node --test",
+    "doctor": "node bin/create-cmp.mjs doctor"
+  },
+  "keywords": [
+    "create-cmp",
+    "create-cmp-cli",
+    "compose-multiplatform",
+    "kotlin-multiplatform",
+    "kmp",
+    "cmp",
+    "scaffold",
+    "android",
+    "ios"
+  ],
+  "license": "MIT",
+  "author": "Karel van der Merwe",
+  "homepage": "https://github.com/kvdm-co-pilot/create-cmp#readme",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/kvdm-co-pilot/create-cmp.git"
+  },
+  "bugs": {
+    "url": "https://github.com/kvdm-co-pilot/create-cmp/issues"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "prompts": "^2.4.2",
+    "picocolors": "^1.1.1"
+  }
+}