@mercury-fw/cli 0.56.0 → 0.57.0

package/CHANGELOG.md

@@ -1,5 +1,36 @@
 # @mercury-fw/cli
 
+## 0.57.0
+
+### Minor Changes
+
+- 377ce2a: `mfw create` gives the app a place for plugins of its own: `plugins/<name>`, each a package, as a workspace of the app (`"workspaces": ["plugins/*"]` in `package.json`), listed in `dependencies` as `workspace:*` and declared in `mercury.config.ts`. A `bunfig.toml` keeps Bun's hoisted `node_modules`: with a workspaces key Bun would switch to its isolated linker, whose `node_modules` is made of links. The Dockerfile copies `bunfig.toml` with `package.json`, then `plugins/` before `bun install`, so a plugin's postinstall finds its own scripts, and puts on PATH the binaries a plugin's postinstall writes to its `bin/`, as it does for the framework's packages. `.dockerignore` leaves out every `node_modules`, a plugin's own included, and the binaries a plugin's postinstall wrote on the host, which `.gitignore` keeps out of the repository too. `package.json` gets a `test` script (`bun test`), which runs the plugins' tests too.
+
+  An existing app keeps working as it is. To give it the same place:
+
+  1. In `package.json`, add `"workspaces": ["plugins/*"]` and `"test": "bun test"` under `scripts`.
+  2. Add a `bunfig.toml` next to it:
+
+     ```toml
+     [install]
+     linker = "hoisted"
+     ```
+
+  3. In the `Dockerfile`, change `COPY --chown=mercury:mercury package.json bun.lock* ./` to `COPY --chown=mercury:mercury package.json bun.lock* bunfig.toml ./`, add `COPY --chown=mercury:mercury plugin[s] ./plugins/` right after `COPY --chown=mercury:mercury .pack[s] ./.packs/`, and replace the line `RUN find /app/node_modules -path '*/@mercury-fw/*/bin/*' -type f -exec ln -sf {} /usr/local/bin/ \;` with:
+
+     ```dockerfile
+     RUN mkdir -p /app/plugins \
+       && find /app/node_modules/@mercury-fw /app/plugins -mindepth 3 -maxdepth 3 -path '*/bin/*' -type f -exec ln -sf {} /usr/local/bin/ \;
+     ```
+
+  4. In `.dockerignore`, change `node_modules` to `**/node_modules` and add `plugins/*/bin`.
+  5. In `.gitignore`, add `plugins/*/bin`.
+
+### Patch Changes
+
+- @mercury-fw/core@0.57.0
+- @mercury-fw/utils@0.57.0
+
 ## 0.56.0
 
 ### Patch Changes

package/README.md

@@ -51,7 +51,7 @@ Writes a new Mercury app into `<folder>`, which has to be missing or empty; the
 - which channels and which tool plugins to include (none is fine: the REPL always works);
 - the git remote for `origin`, which you can leave empty (most of the time it doesn't exist yet when you scaffold).
 
-It writes the `mercury.config.ts` for that selection, the persona, a `locales/` folder with an `en.json` for the texts people see (empty, or the starting formatter rules' own texts: `app.jira.no-issues` with Jira), the service and REPL entrypoints, a Dockerfile, a compose file with Qdrant, and an env example listing every variable the chosen pieces read. A plugin that hands over lists comes wrapped in the formatter with a starting rule, yours to change.
+It writes the `mercury.config.ts` for that selection, the persona, a `locales/` folder with an `en.json` for the texts people see (empty, or the starting formatter rules' own texts: `app.jira.no-issues` with Jira), the service and REPL entrypoints, a Dockerfile, a compose file with Qdrant, and an env example listing every variable the chosen pieces read. Its `package.json` declares `plugins/*` as workspaces, the place for the app's own plugins (each a package in `plugins/<name>`, which the image copies before installing), and a `test` script (`bun test`, the plugins' tests included); `bunfig.toml` keeps Bun's hoisted `node_modules`, which the workspaces would otherwise turn into links. A plugin that hands over lists comes wrapped in the formatter with a starting rule, yours to change.
 
 Then it runs `bun install` in the app and creates a git repository on `main` with a first commit (`bun.lock` included), adding `origin` when you gave one; nothing is pushed. Each step is best effort and never undoes the ones before it: an install that fails still leaves the app committed, without the lockfile, and the closing message says what to run. The repository is skipped when the folder is already inside one (an app created in a monorepo belongs to it). Whether git can commit is git's call: when it refuses (no identity, a hook) or isn't installed, the message reports why and lists the commands to finish by hand. `bun install` prints its own output as it runs.
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mercury-fw/cli",
-  "version": "0.56.0",
+  "version": "0.57.0",
   "type": "module",
   "license": "MIT",
   "repository": {
@@ -41,8 +41,8 @@
   "comment:shape": "The Mercury CLI (`mfw`). `mfw create <dir>` writes a new Mercury app from the template. The framework packages move in lockstep with it, so a new app gets them at the CLI's own version; plugins and channels at the registry's latest. The plugin and channel packages are devDependencies only for the catalog test. `main(argv)` is exported for create-mercury-agent.",
   "dependencies": {
     "@clack/prompts": "^1.8.1",
-    "@mercury-fw/core": "0.56.0",
-    "@mercury-fw/utils": "0.56.0",
+    "@mercury-fw/core": "0.57.0",
+    "@mercury-fw/utils": "0.57.0",
     "commander": "^15.0.0"
   },
   "devDependencies": {
@@ -51,11 +51,11 @@
     "@mercury-fw/channel-google-chat": "0.10.0",
     "@mercury-fw/channel-http": "0.12.0",
     "@mercury-fw/directory-static": "0.1.1",
-    "@mercury-fw/formatter": "0.56.0",
+    "@mercury-fw/formatter": "0.57.0",
     "@mercury-fw/plugin-atlassian-admin": "0.5.0",
     "@mercury-fw/plugin-bitbucket": "0.6.0",
     "@mercury-fw/plugin-jira": "0.8.0",
-    "@mercury-fw/plugin-web-search": "0.3.0",
+    "@mercury-fw/plugin-web-search": "0.4.0",
     "@mercury-fw/plugin-zitadel": "0.5.0",
     "@mercury-fw/typescript-config": "*",
     "@mercury-fw/web-search-searxng": "0.1.0",

package/src/render.ts

@@ -13,6 +13,7 @@ import { CATALOG, type CatalogEntry, type EnvVar } from "./catalog.ts";
 import indexTs from "../template/src/index.ts.tpl" with { type: "text" };
 import replTs from "../template/src/repl.ts.tpl" with { type: "text" };
 import tsconfigJson from "../template/tsconfig.json.tpl" with { type: "text" };
+import bunfigToml from "../template/bunfig.toml.tpl" with { type: "text" };
 import gitignore from "../template/gitignore.tpl" with { type: "text" };
 import dockerignore from "../template/dockerignore.tpl" with { type: "text" };
 import dockerfile from "../template/Dockerfile.tpl" with { type: "text" };
@@ -85,6 +86,7 @@ export function renderApp(input: RenderInput): Map<string, string> {
     [".gitignore", gitignore],
     ["Dockerfile", dockerfile],
     ["README.md", renderReadme(input.name, channels, auth, tools, directory)],
+    ["bunfig.toml", bunfigToml],
     ["docker-compose.yml", renderCompose(input.name, channels.some((c) => c.id === "http"), services)],
     ["locales/en.json", renderEnglish(tools)],
     ["mercury.config.ts", renderConfig(assistantName, input.role, channels, auth, tools, directory)],
@@ -308,7 +310,9 @@ function renderPackageJson(
     version: "0.1.0",
     type: "module",
     private: true,
-    scripts: { start: "bun src/index.ts", repl: "bun src/repl.ts", typecheck: "tsc --noEmit" },
+    // The app's own plugins, each a package of its own under plugins/.
+    workspaces: ["plugins/*"],
+    scripts: { start: "bun src/index.ts", repl: "bun src/repl.ts", typecheck: "tsc --noEmit", test: "bun test" },
     dependencies,
     // The CLI in the app itself, at the framework's version: a global `mfw`
     // hands the app's commands over to it.
@@ -418,6 +422,8 @@ ${directory ? `- Directory: ${directory.id}\n` : ""}
 - \`mercury.config.ts\`: what the app is made of (tool plugins, channels, how their lists read) and the assistant's persona: its name, who it is and how it answers. Edit them freely.
 - \`locales/\`: the texts people see, one file per language the assistant speaks. \`en.json\` overrides the English ones; add \`it.json\` (and \`it\` to \`i18n.locales\` in the config) for Italian, \`i18n.defaultLocale\` for the language people get when they haven't picked one, \`i18n.timeZone\` (an IANA name such as \`Europe/Rome\`) for the time zone of whoever saved none and whose app says none. The app's own texts (a formatter rule's) are \`app.\` keys, written in English in \`en.json\` and translated in every other file. Mercury logs at startup the keys a file is missing.
 - \`src/index.ts\`: the service (channels, crons). \`src/repl.ts\`: an interactive terminal for trying things out.
+- \`plugins/\`: the app's own plugins, when it has any: each one a package in a folder of its own (\`plugins/<name>\`, a workspace), listed in \`dependencies\` as \`workspace:*\` and declared in \`mercury.config.ts\`. \`bun run test\` runs their tests.
+- \`bunfig.toml\`: keeps Bun's hoisted \`node_modules\`, which the workspaces would otherwise turn into links the image's PATH step doesn't follow. Keep it.
 - \`.env.example\`: every variable the app reads. Copy it to \`.env\` and fill it in.
 
 ## Running it

package/template/Dockerfile.tpl

@@ -13,12 +13,17 @@ WORKDIR /app
 
 # Each tool plugin downloads its pinned CLI in its postinstall (allowed by
 # package.json's trustedDependencies); the binaries go on PATH. .packs/ holds
-# local tarballs when the app installs them (mfw local-packages), and is
-# skipped when it isn't there.
-COPY --chown=mercury:mercury package.json bun.lock* ./
+# local tarballs when the app installs them (mfw local-packages), plugins/ the
+# app's own plugins (workspaces, whose postinstall needs their whole folder),
+# and each is skipped when it isn't there. bunfig.toml keeps Bun's hoisted
+# node_modules, which the workspaces would otherwise turn into symlinks.
+COPY --chown=mercury:mercury package.json bun.lock* bunfig.toml ./
 COPY --chown=mercury:mercury .pack[s] ./.packs/
+COPY --chown=mercury:mercury plugin[s] ./plugins/
 RUN bun install --production && chown -R mercury:mercury node_modules
-RUN find /app/node_modules -path '*/@mercury-fw/*/bin/*' -type f -exec ln -sf {} /usr/local/bin/ \;
+# plugins/ made when the app has none, or find fails on it.
+RUN mkdir -p /app/plugins \
+  && find /app/node_modules/@mercury-fw /app/plugins -mindepth 3 -maxdepth 3 -path '*/bin/*' -type f -exec ln -sf {} /usr/local/bin/ \;
 
 COPY --chown=mercury:mercury mercury.config.ts ./
 COPY --chown=mercury:mercury locales ./locales

package/template/bunfig.toml.tpl

@@ -0,0 +1,2 @@
+[install]
+linker = "hoisted"

package/template/dockerignore.tpl

@@ -1,6 +1,7 @@
-node_modules
+**/node_modules
 .git
 .env
 .env.*
 !.env.example
 *.log
+plugins/*/bin

package/template/gitignore.tpl

@@ -6,3 +6,4 @@ node_modules
 .DS_Store
 .packs/
 e2e/results/
+plugins/*/bin