@mercury-fw/cli 0.55.0 → 0.57.0

package/CHANGELOG.md

@@ -1,5 +1,57 @@
 # @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
+
+- 1126106: Every turn tells the model when and where the person wrote it.
+
+  - Each message reaches the model after a line with the weekday, date, time and time zone it was written in (`[Wednesday 2026-10-21 14:32 Europe/Rome]`), and the system prompt says what that line is. The conversation's archive and what a UI shows of it keep the message as written.
+  - A resumed conversation's messages come back stamped from the archive's timestamps.
+  - The Layer 1 summary keeps when things were said; the episodic summary quotes a date only from those lines, never guessing one. The semantic-fact extractor and the capture card's preview leave the line out.
+  - The time zone, always an IANA name (`Europe/Rome`), is the one the person saved, else the one their client is in when the channel passes it on, else the new `i18n.timeZone` in `mercury.config.ts`, else the machine's. A `timeZone` that isn't a zone's name stops the start.
+  - The person saves theirs by telling the assistant (the new `set_time_zone` tool), or from a channel's settings.
+  - Channel contract: `InboundTurn.timeZoneHint`, and `ctx.settings.setTimeZone` for a channel with a settings area; `reads.me` also returns the saved `timeZone`. Both are optional additions: the contract version stays 6.
+  - HTTP channel: the `X-Time-Zone` header on `POST /turn` (allowed by CORS), `timeZone` in `GET /me`, and `PATCH /me` with `{ timeZone }` to save it. Needs the framework at 0.56 or later; an older core ignores the header and offers no `PATCH /me`.
+  - Google Chat channel: the client's time zone (`common.timeZone`), when the event carries it, on messages and on the turn a click resumes.
+
+  To set a default for an app's people, add `timeZone: "Europe/Rome"` (their zone) to `i18n` in `mercury.config.ts`; without it the machine's zone is used, often UTC inside a container.
+
+- Updated dependencies [1126106]
+  - @mercury-fw/core@0.56.0
+  - @mercury-fw/utils@0.56.0
+
 ## 0.55.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.55.0",
+  "version": "0.57.0",
   "type": "module",
   "license": "MIT",
   "repository": {
@@ -41,21 +41,21 @@
   "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.55.0",
-    "@mercury-fw/utils": "0.55.0",
+    "@mercury-fw/core": "0.57.0",
+    "@mercury-fw/utils": "0.57.0",
     "commander": "^15.0.0"
   },
   "devDependencies": {
     "@mercury-fw/auth-oidc": "0.2.0",
     "@mercury-fw/auth-static": "0.2.1",
-    "@mercury-fw/channel-google-chat": "0.9.0",
-    "@mercury-fw/channel-http": "0.11.0",
+    "@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.55.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.
@@ -416,8 +420,10 @@ ${directory ? `- Directory: ${directory.id}\n` : ""}
 ## Layout
 
 - \`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. 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.
+- \`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