@twobirds/microcomponents 0.5.0 → 0.7.0

package/README.md

@@ -46,6 +46,21 @@ An MCP (Model Context Protocol) server ships with the package so AI assistants c
 microcomponents-mcp   # stdio server, straight from the installed package
 ```
 
+`mc create` writes an `opencode.jsonc` into every scaffolded project, so opencode picks the server up as soon as you open the project — no config edit needed. opencode reads the project config from the repo root, and the server is started through `npx`, which resolves the version the project installed:
+
+```jsonc
+{
+	"$schema": "https://opencode.ai/config.json",
+	"mcp": {
+		"microcomponents": {
+			"type": "local",
+			"command": ["npx", "-p", "@twobirds/microcomponents", "microcomponents-mcp"],
+			"enabled": true,
+		},
+	},
+}
+```
+
 In a published package the server runs from `dist/mcp` and reads the prebuilt `api.json` and the concept essays that the build step emits next to it. During development it generates the index live from `src/` at startup, so it cannot drift away from the library it documents:
 
 ```bash
@@ -80,11 +95,12 @@ pnpm run cli -- new my-card --target-html --target-css --dry-run
 # would create src/my/card.target.css
 ```
 
-`mc create` scaffolds a complete dev environment for a namespace — a Vite dev server serving `src/` straight, a page shell that turns on `autoload(true)`, and a starter component with companion assets:
+`mc create` scaffolds a complete dev environment for a namespace — a Vite dev server serving `src/` straight, a page shell that turns on `autoload(true)`, a starter component with companion assets, and an `opencode.jsonc` that registers the MCP server:
 
 ```bash
 pnpm run cli -- create --namespace mc --dir mc-app
 # created mc-app/package.json
+# created mc-app/opencode.jsonc
 # created mc-app/src/index.html
 # created mc-app/src/mc/app.ts
 # created mc-app/src/mc/app.target.html
@@ -109,16 +125,31 @@ pnpm run cli -- create --namespace mc
 # rerun with --force to overwrite
 ```
 
-Once installed from npm the same command is available as `mc`:
+Once installed from npm the same command is available as `mc` (and as `microcomponents`, the same executable under the package name):
 
 ```bash
 mc new my-card [--css] [--html] [--target-html] [--shadow-html] [--target-css] [--shadow-css] [--js] [--dir <path>] [--force] [--dry-run]
 mc create --namespace <ns> [--dir <path>] [--force] [--dry-run]
 mc clean
 mc check
+mc --version
 ```
 
-`clean` and `check` are thin wrappers around the package.json scripts of the same name, so the scripts remain the single source of truth for what they do — `mc check` type-checks every project context (lib, cli, mcp, test, demo, node) and exits with the script's exit code.
+`clean` and `check` are thin wrappers around the package.json scripts of the same name, so the scripts remain the single source of truth for what they do — `mc check` type-checks every project context (lib, cli, mcp, test, demo, node) and exits with the script's exit code. `mc --version` (`-v`) prints the version of the package the CLI ships in, read from its own package.json, so it reports the installed library, not the version of the project the command runs in.
+
+Nothing has to be installed to run it once — `npx` fetches the package into its own cache and runs the bin from there:
+
+```bash
+npx @twobirds/microcomponents mc --help
+npx @twobirds/microcomponents new my-card --target-html --target-css --dry-run
+```
+
+`npx <package>` alone has no bin name to run, so npm picks the bin whose key matches the unscoped package name — that is why `bin` lists `microcomponents` next to `mc`. With `-p` the package is named explicitly and the word after it is read as the bin name, so `mc` and the MCP server can be started by name:
+
+```bash
+npx -p @twobirds/microcomponents mc new my-card --target-html --target-css
+npx -p @twobirds/microcomponents microcomponents-mcp
+```
 
 The scaffold derives the file path from the tag using the same rule the runtime autoload loader uses (`my-card` → `my/card.ts`), names companion assets after the runtime's asset descriptors (`targetHtml` → `card.target.html`), and wires them into a `static assets` declaration. `--js` emits a plain JavaScript file for the rapid-prototyping path.
 

package/dist/cli/create.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"create.d.ts","sourceRoot":"","sources":["../../src/cli/create.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;EAkBE;AAUF;;;;;;;;;;EAUE;AACF,wBAAgB,gBAAgB,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAEpD;AAED,yCAAyC;AACzC,MAAM,WAAW,aAAa;IAC7B,kEAAkE;IAClE,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC9B,+BAA+B;IAC/B,SAAS,EAAE,MAAM,CAAC;CAClB;AAED;;;;;;;;;;;;EAYE;AACF,wBAAgB,eAAe,CAAC,SAAS,EAAE,MAAM,GAAG,aAAa,CAuBhE"}
+{"version":3,"file":"create.d.ts","sourceRoot":"","sources":["../../src/cli/create.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;EAkBE;AAUF;;;;;;;;;;EAUE;AACF,wBAAgB,gBAAgB,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAEpD;AAED,yCAAyC;AACzC,MAAM,WAAW,aAAa;IAC7B,kEAAkE;IAClE,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC9B,+BAA+B;IAC/B,SAAS,EAAE,MAAM,CAAC;CAClB;AAED;;;;;;;;;;;;EAYE;AACF,wBAAgB,eAAe,CAAC,SAAS,EAAE,MAAM,GAAG,aAAa,CAwBhE"}

package/dist/cli/create.js

@@ -62,6 +62,7 @@ export function scaffoldProject(namespace) {
     files['tsconfig.vc.json'] = tsconfigVc();
     files['vite.config.ts'] = viteConfig(namespace);
     files['.gitignore'] = gitignore();
+    files['opencode.jsonc'] = opencodeConfig();
     files['README.md'] = readme(namespace, tag);
     files['src/index.html'] = shell(namespace, tag);
     files[`src/${base}.ts`] = appSource(namespace, tag);
@@ -81,7 +82,7 @@ function packageJson(namespace) {
             typecheck: 'tsc --noEmit -p tsconfig.json && tsc --noEmit -p tsconfig.vc.json',
         },
         dependencies: {
-            '@twobirds/microcomponents': '^0.5.0',
+            '@twobirds/microcomponents': '^0.7.0',
         },
         devDependencies: {
             vite: '^8.1.5',
@@ -126,6 +127,18 @@ function gitignore() {
 dist/
 `;
 }
+function opencodeConfig() {
+    return JSON.stringify({
+        $schema: 'https://opencode.ai/config.json',
+        mcp: {
+            microcomponents: {
+                type: 'local',
+                command: ['npx', '-p', '@twobirds/microcomponents', 'microcomponents-mcp'],
+                enabled: true,
+            },
+        },
+    }, null, '\t');
+}
 function readme(namespace, tag) {
     return `# ${namespace} App
 

package/dist/cli/dispatch.d.ts

@@ -38,6 +38,10 @@ const code = await main(['clean'], async (script) => {
     return 0;
 });
 ```
+@example
+```ts
+const code = await main(['--version']);
+```
 */
 export declare function main(argv: string[], run?: Runner): Promise<number>;
 //# sourceMappingURL=dispatch.d.ts.map

package/dist/cli/dispatch.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"dispatch.d.ts","sourceRoot":"","sources":["../../src/cli/dispatch.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;EAYE;AAsDF,MAAM,MAAM,MAAM,GAAG,CAAC,MAAM,EAAE,MAAM,KAAK,OAAO,CAAC,MAAM,CAAC,CAAC;AAqGzD;;;;;;;;;;;;EAYE;AACF,wBAAsB,SAAS,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAQ/D;AAED;;;;;;;;;;;;EAYE;AACF,wBAAsB,IAAI,CAAC,IAAI,EAAE,MAAM,EAAE,EAAE,GAAG,GAAE,MAAkB,GAAG,OAAO,CAAC,MAAM,CAAC,CAwGnF"}
+{"version":3,"file":"dispatch.d.ts","sourceRoot":"","sources":["../../src/cli/dispatch.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;EAYE;AA0DF,MAAM,MAAM,MAAM,GAAG,CAAC,MAAM,EAAE,MAAM,KAAK,OAAO,CAAC,MAAM,CAAC,CAAC;AAwHzD;;;;;;;;;;;;EAYE;AACF,wBAAsB,SAAS,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAQ/D;AAED;;;;;;;;;;;;;;;;EAgBE;AACF,wBAAsB,IAAI,CAAC,IAAI,EAAE,MAAM,EAAE,EAAE,GAAG,GAAE,MAAkB,GAAG,OAAO,CAAC,MAAM,CAAC,CA8GnF"}

package/dist/cli/dispatch.js

@@ -26,6 +26,8 @@ Usage:
   mc create --namespace <ns> [--dir <path>] [--force] [--dry-run]
   mc clean
   mc check
+  mc --version
+  mc --help
 
 Commands:
   new <tag>   Scaffold a micro component (e.g. mc new my-card --target-html --target-css)
@@ -46,6 +48,8 @@ Other options:
   --dir <path> scaffold root (default: src)
   --force      overwrite files that already exist
   --dry-run    print what would be written; touch nothing on disk
+  --version    print the version of the package the CLI ships in (-v)
+  --help       print this text (-h)
 
 Created paths are printed as they appear from the current directory. mc create writes
 a whole project into a folder of its own (default: the namespace), so its files show
@@ -153,6 +157,22 @@ async function checkSelf(cwd = process.cwd()) {
     return spawnProcess('pnpm', ['exec', 'tsc', '--noEmit', '-p', 'tsconfig.json'], cwd);
 }
 /**
+The version of the package the CLI ships in, read from its package.json. Two
+levels above `dist/cli` (and above `src/cli` when tsx runs the source) is the
+package root, so the CLI reports the version it was installed with, not the
+version of the project it is run in.
+
+@example
+```ts
+const version = await readVersion();
+```
+@param pkgPath - package.json to read (defaults to the package root of this CLI).
+*/
+async function readVersion(pkgPath = path.join(import.meta.dirname, '..', '..', 'package.json')) {
+    const { version } = JSON.parse(await readFile(pkgPath, 'utf8'));
+    return version;
+}
+/**
 Runs a package.json script through pnpm and resolves with its exit code.
 
 Thin wrappers like `clean` and `check` delegate here so the script — not the
@@ -188,6 +208,10 @@ const code = await main(['clean'], async (script) => {
     return 0;
 });
 ```
+@example
+```ts
+const code = await main(['--version']);
+```
 */
 export async function main(argv, run = runScript) {
     const { values, positionals } = parseArgs({
@@ -206,9 +230,14 @@ export async function main(argv, run = runScript) {
             force: { type: 'boolean' },
             'dry-run': { type: 'boolean' },
             help: { type: 'boolean', short: 'h' },
+            version: { type: 'boolean', short: 'v' },
         },
     });
     const command = positionals[0];
+    if (values.version) {
+        console.log(await readVersion());
+        return 0;
+    }
     if (values.help || !command) {
         console.log(USAGE);
         return 0;

package/dist/mcp/api.json

@@ -1,5 +1,5 @@
 {
-  "libraryVersion": "0.5.0",
+  "libraryVersion": "0.7.0",
   "exportedCount": 41,
   "entries": {
     "MC": {

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@twobirds/microcomponents",
-	"version": "0.5.0",
+	"version": "0.7.0",
 	"description": "Micro Components",
 	"keywords": [
 		"PWA",
@@ -34,6 +34,7 @@
 	},
 	"bin": {
 		"mc": "./dist/cli/index.js",
+		"microcomponents": "./dist/cli/index.js",
 		"microcomponents-mcp": "./dist/mcp/index.js"
 	},
 	"files": [