@mercury-fw/cli 0.29.4 → 0.31.0

package/CHANGELOG.md

@@ -1,5 +1,33 @@
 # @mercury-fw/cli
 
+## 0.31.0
+
+### Minor Changes
+
+- 6ae8133: - `mfw local-packages <folder>` makes an app install `@mercury-fw/*` packages from local tarballs (`bun pm pack`) instead of the registry, transitive dependencies included; `--off` goes back to the registry.
+  - `mfw e2e` runs end-to-end tests against an app's real model through its REPL: cases of turns with checks on the tool calls and the answer, repeated runs, results kept in `e2e/results/`.
+  - Test files declare their cases with `e2e()` from `@mercury-fw/cli/e2e`.
+  - A new app's Dockerfile copies `.packs/` when present, and its `.gitignore` leaves out `.packs/` and `e2e/results/`.
+  - In the REPL, `/dump` after a confirmation no longer writes the turn before it.
+
+### Patch Changes
+
+- Updated dependencies [6ae8133]
+  - @mercury-fw/core@0.31.0
+
+## 0.30.0
+
+### Minor Changes
+
+- 238d4dc: - `mfw create` runs `bun install` in the new app, showing its output as it goes (`--no-install` to skip it).
+  - `mfw create` creates a git repository on `main` with a first commit, lockfile included (`--no-git` to skip it); inside another repository it is skipped, and when git refuses a step or is missing, the message reports why and lists the commands to finish by hand.
+  - `mfw create` adds `origin` when given one, in the wizard or with `--git-remote`; nothing is pushed.
+  - The message at the end of `mfw create` lists what each step did and only the steps left to run.
+
+### Patch Changes
+
+- @mercury-fw/core@0.30.0
+
 ## 0.29.4
 
 ### Patch Changes

package/README.md

@@ -20,6 +20,8 @@
   - [`mfw credentials set <plugin> [--from <dir>] [--print]`](#mfw-credentials-set-plugin---from-dir---print)
   - [`mfw credentials reset <plugin>`](#mfw-credentials-reset-plugin)
   - [`mfw google-chat set-key <key-file> [--subscription <name>]`](#mfw-google-chat-set-key-key-file---subscription-name)
+  - [`mfw local-packages <folder>` / `mfw local-packages --off`](#mfw-local-packages-folder--mfw-local-packages---off)
+  - [`mfw e2e [tests...] [--repeat N]`](#mfw-e2e-tests---repeat-n)
   - [`mfw upgrade`](#mfw-upgrade)
 - [Help](#help)
 
@@ -44,9 +46,12 @@ Writes a new Mercury app into `<folder>`, which has to be missing or empty; the
 
 - the app name (the `name` in `package.json`, defaulting to the folder's);
 - the assistant's name and role, which become `persona/identity.md` ("You are Hermes, the platform team's release assistant.") next to a `persona/tone.md` to edit;
-- which channels and which tool plugins to include (none is fine: the REPL always works).
+- 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, 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. Nothing is installed: run `bun install` in the new app.
+It writes the `mercury.config.ts` for that selection, the persona, 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.
+
+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.
 
 | Flag | |
 |---|---|
@@ -55,6 +60,9 @@ It writes the `mercury.config.ts` for that selection, the persona, the service a
 | `--role <text>` | Completes "You are <name>, …" (default `an internal assistant`). |
 | `--channels <ids>` | Comma-separated: `google-chat`, `http`. |
 | `--plugins <ids>` | Comma-separated: `jira`, `bitbucket`, `atlassian-admin`. |
+| `--git-remote <url>` | The repository's `origin`, taken as typed. |
+| `--no-install` | Don't run `bun install`. |
+| `--no-git` | Don't create the repository. |
 | `-y`, `--yes` | No questions: the flags, and the defaults for the rest. |
 
 ```bash
@@ -206,6 +214,88 @@ mfw google-chat set-key key.json --subscription projects/my-project/subscription
 mfw google-chat set-key new-key.json
 ```
 
+### `mfw local-packages <folder>` / `mfw local-packages --off`
+
+Makes the app install `@mercury-fw/*` packages from local tarballs instead of the registry: the way to try a framework or plugin change in a real app before it's published. `<folder>` holds the `.tgz` files `bun pm pack` writes, one per package; the command copies them into the app's `.packs/`, points each package at its tarball with `overrides` in `package.json`, and runs `bun install`.
+
+Overrides, and not the dependencies themselves, because a packed package names the packages it depends on by version, and the registry has those versions too: only an override sends them to the tarballs as well (a packed `@mercury-fw/core` depends on `@mercury-fw/plugin-types`, for example). The Dockerfile `mfw create` writes copies `.packs/` before installing, so the image gets the same packages (an app created before 0.31.0 needs `COPY --chown=mercury:mercury .pack[s] ./.packs/` added after the line copying `package.json`); `.gitignore` leaves it out of the repository.
+
+Run it again after packing anew: it replaces the tarballs and the overrides of the previous run, and leaves alone the overrides you wrote yourself. `--off` takes the app back to the registry: the overrides it wrote and `.packs/` go, then `bun install`. After either, `mfw start` rebuilds the image with the packages now installed.
+
+```bash
+mfw local-packages ../mercury-fw/apps/testbed/.packs
+mfw local-packages --off
+```
+
+### `mfw e2e [tests...] [--repeat N]`
+
+Runs end-to-end tests against the app's real model: each test case sends its turns to the app's REPL in the container, as `mfw repl` would, and checks what each turn did, the tool calls with their inputs and results, and the answer. It's how you find out whether the model actually uses a plugin the way its skill says, at the first try, with the app's own model, configuration, wiki and credentials. That's also why it doesn't belong in CI: the results depend on the model, on what's in the vault and in Qdrant, and on accounts a CI runner shouldn't have.
+
+Without arguments it runs every `e2e/*.e2e.ts` in the app; with files, those (they can live anywhere). It prints every check of every run, keeps everything (each turn's calls and answer, each check) in `e2e/results/<time>/`, which `.gitignore` leaves out, and exits 1 when a case didn't pass. The app must be built and its `.env` filled in, as for `mfw repl`. `--repeat N` runs each case N times, overriding its own `repeat`.
+
+#### Writing a test
+
+A test is a TypeScript file whose default export is `e2e({ … })`, from `@mercury-fw/cli/e2e` (every app has the CLI among its devDependencies, so the types are there):
+
+```ts
+import { e2e } from "@mercury-fw/cli/e2e";
+
+export default e2e({
+  // What the app must have, by catalog id: checked before anything runs.
+  plugins: ["jira"],
+  channels: [],
+  cases: [
+    {
+      name: "project key, at the first try",
+      turns: ["On Jira, what is the project key of Customer Support?"],
+      repeat: 3, // the model isn't deterministic
+      minPasses: 3, // how many runs must pass; default every one
+      check: (run, expect) => {
+        expect.everyCall("jiraCommand", (c) => String((c.input as { command: string }).command).includes("--select "));
+        expect.noFailedCalls();
+        expect.callCount({ max: 3 });
+        expect.answer(/\bCS\b/);
+      },
+    },
+  ],
+});
+```
+
+Each run of a case gets a fresh REPL session. `check` receives the run, `run.turns` in order and `run.last`, each turn with:
+
+- `calls`: the tool calls, each with `tool`, `input`, `output`, `ok` (false for a failed call, or one that never got a result) and `pending` (an irreversible command staged for confirmation: it worked, and its output holds the token);
+- `answer`: the turn's final text (what the model wrote; a list `present` adds afterwards isn't part of it);
+- `seconds`: how long it took, for the report.
+
+The `expect` helpers record a named check each and never stop the others, so a failed run shows every check that failed:
+
+| Helper | Passes when |
+|---|---|
+| `call(tool, match?)` | at least one call to `tool` (matching `match`, when given) |
+| `everyCall(tool, match)` | there are calls to `tool`, and every one matches |
+| `noFailedCalls()` | no call failed |
+| `callCount({ min?, max? }, tool?)` | the number of calls, to any tool or to `tool`, is within the bounds |
+| `answer(text \| regex)` | the last answer contains the text, or matches |
+| `answerNot(text \| regex)` | it doesn't |
+| `that(label, condition)` | `condition` is true |
+
+The call helpers look at every turn of the run, the answer helpers at the last one; each takes an optional label as its last argument. A case that records no check fails: it proves nothing.
+
+A turn can be a function of the one before, for a follow-up or a confirmation: `(previous) => …` returns the next message from `previous.calls` and `previous.answer` (an irreversible command comes back as a call whose output holds the pending confirmation's token, and sending the token as the next turn confirms it). Each turn is one line, as the REPL reads them.
+
+`before`, `after` and `check` also get `cli(command)`, which runs `sh -c command` in the app's container, outside the model, and resolves to its exit code and output: to prepare data (an issue to work on, a note in the wiki with the vault CLI), to check what a turn changed (`jira issue get KEY --select fields.assignee.displayName` after an assignment), to clean up. `after` runs even when the run or the check failed. A test that changes an external system has to clean up after itself, so start from read-only ones.
+
+#### What it can and can't test
+
+It can test how the model uses a plugin through its skill (the commands and flags it picks, rejected or failed calls, how many calls it takes), what the answer says or must not say, what a turn changed in an external system, the confirmation of an irreversible command, conversations over several turns, several plugins working together, and what the wiki and memory make of a conversation.
+
+It can't test how a channel shows a turn (Google Chat's cards, the HTTP channel's events: the REPL runs the same turn, without them), the background jobs (the nightly wiki review, idle-session capture), or the exact wording of an answer: checks look for properties, and `repeat` with `minPasses` says how steady the behaviour is. Durations are in the report and in `e2e/results/`, never a check.
+
+```bash
+mfw e2e
+mfw e2e e2e/jira.e2e.ts --repeat 3
+```
+
 ### `mfw upgrade`
 
 Installs the registry's latest `mfw` globally (`bun add -g @mercury-fw/cli@<latest>`) when it's newer than the one running, and says it's already the latest otherwise; a registry that doesn't answer exits 1. It's about the global `mfw` only: an app's framework, its own CLI included, moves with `bun update` in the app. `mfw create` run by a stale global `mfw` creates the app with the latest one anyway, and says to run this.

package/dist/src/app/commands.d.ts

@@ -74,6 +74,19 @@ export declare function appCommands(app: App, deps: AppDeps): {
     googleChatSetKey: (keyFile: string, { subscription }: {
         subscription?: string;
     }) => Promise<number>;
+    /** Makes the app install the packages in `from`'s tarballs (`bun pm
+     * pack`) instead of the registry's: copied into `.packs/` (which the
+     * image copies too), overridden in the manifest, then installed.
+     * Everything is checked before anything is written. */
+    localPackages: (from: string) => Promise<number>;
+    /** Runs e2e tests (`tests`, or the app's `e2e/*.e2e.ts`) against the app's
+     * REPL in its container, keeping the turns and checks in
+     * `e2e/results/<time>/`; returns 1 when a case didn't pass. */
+    e2e: (tests: string[], { repeat }: {
+        repeat?: number;
+    }) => Promise<number>;
+    /** Undoes `localPackages`: the app installs from the registry again. */
+    localPackagesOff: () => Promise<number>;
 };
 /** The real deps: docker on the user's terminal, questions on `input`
  * (stdin by default). */

package/dist/src/app/local-packages.d.ts

@@ -0,0 +1,26 @@
+/**
+ * What `mfw local-packages` writes: the app's `package.json` with `overrides`
+ * pointing packages at local tarballs (`bun pm pack`) copied into `.packs/`,
+ * which the image copies before `bun install`. Overrides, and not the
+ * dependencies themselves, because a packed package names its siblings by
+ * version, which the registry has too: only an override sends those
+ * transitive dependencies to the tarballs as well.
+ */
+/** The tarballs' folder inside the app, as the Dockerfile copies it. */
+export declare const LOCAL_PACKS_DIR = ".packs";
+type Manifest = Record<string, unknown> & {
+    overrides?: Record<string, string>;
+};
+/** `pkg` with each of `packs` (a package name and its tarball's file name in
+ * `.packs/`) as an override, in place of any left by an earlier run. */
+export declare function withLocalOverrides(pkg: Manifest, packs: Array<{
+    name: string;
+    file: string;
+}>): Manifest;
+/** `pkg` without the overrides this command writes; without `overrides` at
+ * all when none of the user's own is left. */
+export declare function withoutLocalOverrides(pkg: Manifest): Manifest;
+/** The package name in a `bun pm pack` tarball, read from its
+ * `package/package.json`. */
+export declare function packageNameOf(tarball: string): Promise<string>;
+export {};

package/dist/src/args.d.ts

@@ -14,7 +14,13 @@ export type CreateArgs = {
     role?: string;
     channels?: string[];
     plugins?: string[];
+    /** The repository's origin, taken as typed. */
+    gitRemote?: string;
     yes: boolean;
+    /** Run `bun install` after writing (`--no-install` turns it off). */
+    install: boolean;
+    /** Create the repository with a first commit (`--no-git` turns it off). */
+    git: boolean;
 };
 /** `create`'s options as commander hands them over. */
 export type CreateOptions = {
@@ -23,7 +29,10 @@ export type CreateOptions = {
     role?: string;
     channels?: string;
     plugins?: string;
+    gitRemote?: string;
     yes?: boolean;
+    install?: boolean;
+    git?: boolean;
 };
 /** The answers in `folder` and `opts`, with only what was actually given. */
 export declare function toCreateArgs(folder: string, opts: CreateOptions): CreateArgs;

package/dist/src/e2e/define.d.ts

@@ -0,0 +1,73 @@
+/**
+ * The shape of an e2e test, as a test file imports it
+ * (`import { e2e } from "@mercury-fw/cli/e2e"`): the plugins and channels the
+ * app must have, and cases of turns sent to the app's real model through its
+ * REPL, each with checks on the calls it made and the answer it gave.
+ * `mfw e2e` runs them (`runner.ts`).
+ */
+import type { Call, TurnData } from "./dump.ts";
+export type { Call } from "./dump.ts";
+/** One turn as a check sees it: its calls, its answer, how long it took. */
+export type Turn = TurnData & {
+    seconds: number;
+};
+/** A case's run: every turn in order, and the last one. */
+export type Run = {
+    turns: Turn[];
+    last: Turn;
+};
+/** Runs `command` in the app's container (`sh -c`), outside the model:
+ * preparing data, reading what a turn changed, cleaning up. */
+export type Cli = (command: string) => Promise<{
+    code: number;
+    output: string;
+}>;
+/** What `before`, `after` and `check` can reach besides the run. */
+export type Context = {
+    cli: Cli;
+};
+/** The checks a case makes. Call helpers look at every turn's calls, answer
+ * helpers at the last answer; each records a named check and never throws,
+ * so a case reports every failure at once. */
+export type Expect = {
+    /** At least one call to `tool`, matching `match` when given. */
+    call(tool: string, match?: (call: Call) => boolean, label?: string): void;
+    /** Every call to `tool` matches `match` (and there is at least one). */
+    everyCall(tool: string, match: (call: Call) => boolean, label?: string): void;
+    /** No call failed or went without a result. */
+    noFailedCalls(label?: string): void;
+    /** The number of calls, to every tool or to `tool`, within the bounds. */
+    callCount(bounds: {
+        min?: number;
+        max?: number;
+    }, tool?: string, label?: string): void;
+    /** The answer contains `pattern`, or matches it. */
+    answer(pattern: string | RegExp, label?: string): void;
+    /** The answer doesn't contain `pattern`, or doesn't match it. */
+    answerNot(pattern: string | RegExp, label?: string): void;
+    /** Anything else. */
+    that(label: string, condition: boolean): void;
+};
+/** One case: the turns sent, in one REPL session, and the checks on them. */
+export type E2eCase = {
+    name: string;
+    /** A message, or a function of the turn before (a follow-up, a confirmation token). */
+    turns: Array<string | ((previous: Turn) => string)>;
+    /** How many times to run it (the model isn't deterministic); default 1. */
+    repeat?: number;
+    /** How many runs must pass; default every one. */
+    minPasses?: number;
+    before?: (ctx: Context) => unknown;
+    after?: (ctx: Context) => unknown;
+    check: (run: Run, expect: Expect, ctx: Context) => unknown;
+};
+/** An e2e test: what the app must have, and its cases. */
+export type E2eTest = {
+    /** Catalog ids of the tool plugins the app must have (`jira`, …). */
+    plugins?: string[];
+    /** Catalog ids of the channels the app must have (`http`, …). */
+    channels?: string[];
+    cases: E2eCase[];
+};
+/** Declares an e2e test: the identity, there for the types. */
+export declare function e2e(test: E2eTest): E2eTest;

package/dist/src/e2e/dump.d.ts

@@ -0,0 +1,24 @@
+/**
+ * A turn read out of the file the REPL's `/dump` writes: the AI SDK's step
+ * results for the last turn, whose `content` parts are the tool calls, their
+ * results (or errors) and the model's text. Read as data, not through the
+ * SDK's types: only the parts listed here matter.
+ */
+/** One tool call as a check sees it. `ok` is false when the call failed or
+ * never got a result; a result without an `ok` of its own counts as worked.
+ * `pending` is an irreversible command staged for confirmation, which worked
+ * (its output has the token) though it reports `ok: false`. */
+export type Call = {
+    tool: string;
+    input: unknown;
+    output: unknown;
+    ok: boolean;
+    pending: boolean;
+};
+/** What a turn did: its tool calls in order, and its final text. */
+export type TurnData = {
+    calls: Call[];
+    answer: string;
+};
+/** The calls and the answer in `dump`, the parsed content of a `/dump` file. */
+export declare function turnFromDump(dump: unknown): TurnData;

package/dist/src/e2e/expect.d.ts

@@ -0,0 +1,12 @@
+import type { Expect, Run } from "./define.ts";
+/** One check's outcome; `detail` says what was found when it failed. */
+export type Check = {
+    label: string;
+    ok: boolean;
+    detail?: string;
+};
+/** An `expect` bound to `run`, and the checks it recorded so far. */
+export declare function createExpect(run: Run): {
+    expect: Expect;
+    checks: () => Check[];
+};

package/dist/src/e2e/load.d.ts

@@ -0,0 +1,9 @@
+import type { E2eTest } from "./define.ts";
+/** The files to run: `named` resolved from `cwd`, or, when none is named,
+ * the app's `e2e/*.e2e.ts` in name order. */
+export declare function findTests(named: string[], { appDir, cwd }: {
+    appDir: string;
+    cwd: string;
+}): string[];
+/** The test `file` exports as default; throws naming the file when it isn't one. */
+export declare function loadTest(file: string): Promise<E2eTest>;

package/dist/src/e2e/runner.d.ts

@@ -0,0 +1,42 @@
+import type { Context, E2eTest, Turn } from "./define.ts";
+import { type Check } from "./expect.ts";
+/** A REPL session in the app: `turn` sends one line and resolves with what
+ * `/dump` wrote for it and what the REPL printed meanwhile. */
+export type Session = {
+    turn: (line: string) => Promise<{
+        dump: unknown;
+        output: string;
+    }>;
+    close: () => Promise<void>;
+};
+export type RunnerDeps = {
+    openSession: () => Promise<Session>;
+    cli: Context["cli"];
+    /** The app's dependencies, to check the test's plugins and channels against. */
+    appPackages: Record<string, string>;
+    print: (line: string) => void;
+    /** Milliseconds, for each turn's duration. */
+    now: () => number;
+    writeReport: (report: CaseReport[]) => Promise<void>;
+};
+/** One run of a case, as the report keeps it. */
+export type RunReport = {
+    ok: boolean;
+    turns: Turn[];
+    checks: Check[];
+};
+export type CaseReport = {
+    file: string;
+    case: string;
+    passed: boolean;
+    runs: RunReport[];
+};
+/** Runs the tests in `tests` (each with the file it came from); returns the
+ * exit code: 0 when every case passed enough runs. `repeat` overrides each
+ * case's own. */
+export declare function runE2e(tests: Array<{
+    file: string;
+    test: E2eTest;
+}>, opts: {
+    repeat?: number;
+}, deps: RunnerDeps): Promise<number>;

package/dist/src/e2e/session.d.ts

@@ -0,0 +1,17 @@
+import type { Session } from "./runner.ts";
+export type ReplSessionOptions = {
+    /** The command that starts the REPL. */
+    argv: string[];
+    cwd: string;
+    /** Where the dumps are, on this side, and as the REPL sees the same folder. */
+    hostDir: string;
+    replDir: string;
+    /** Prefix of this session's dump files, unique among sessions sharing the folder. */
+    name: string;
+    /** How long one turn may take. */
+    timeoutMs: number;
+};
+/** Starts the REPL and returns the session over it once the REPL is ready
+ * (its first prompt is out), so a turn's time is only the turn's; throws
+ * when the REPL exits or doesn't get there in time. */
+export declare function openReplSession(opts: ReplSessionOptions): Promise<Session>;

package/dist/src/finish.d.ts

@@ -0,0 +1,52 @@
+/**
+ * What `mfw create` does once the app's files are written: `bun install`, then
+ * a git repository on `main` with a first commit and, when given, its origin
+ * (never pushed: that stays the user's). Every step is best effort: a failure
+ * never undoes what came before, and the report says what happened, which
+ * `finishMessage` turns into the command's last words, next steps included.
+ */
+/** Runs `argv` in `cwd`; resolves with its exit code and its output (stdout
+ * and stderr together), or with an empty output when `live` sends it straight
+ * to the terminal. A missing binary resolves with a non-zero code. */
+export type Run = (argv: string[], cwd: string, opts?: {
+    live?: boolean;
+}) => Promise<{
+    code: number;
+    output: string;
+}>;
+/** Why git is skipped for an app created inside another repository: on
+ * purpose, so there's nothing to finish by hand. */
+export declare const INSIDE_A_REPOSITORY = "the folder is already inside a git repository";
+/** What to do after writing: `remote` is taken as typed. */
+export type FinishOptions = {
+    install: boolean;
+    git: boolean;
+    remote?: string;
+    /** The first commit's message, one `-m` per paragraph. */
+    commitMessage: string[];
+};
+/** A step that ran (`done`), wasn't asked for (`off`), was skipped with a
+ * reason, or failed with the command's output. */
+type Outcome = "done" | "off" | {
+    failed: string;
+};
+export type FinishReport = {
+    install: Outcome;
+    git: Outcome | {
+        skipped: string;
+    };
+    remote: Outcome;
+};
+/** The real runner: a child process with its output captured. */
+export declare const spawnRun: Run;
+/** Runs the steps after writing the app in `dir`; see the file's comment. */
+export declare function finishApp(dir: string, opts: FinishOptions, run: Run): Promise<FinishReport>;
+/** The command's closing output: where the app is, what the steps after
+ * writing did, and what's left to run. */
+export declare function finishMessage(app: {
+    name: string;
+    dir: string;
+    remote?: string;
+    report: FinishReport;
+}): string;
+export {};

package/dist/src/main.d.ts

@@ -1,4 +1,5 @@
 import { type AppDeps } from "./app/commands.ts";
+import { type Run } from "./finish.ts";
 /** Runs `argv` with stdio inherited and `env` on top of this process's
  * environment; returns its exit code. */
 export type Relaunch = (argv: string[], env: Record<string, string>, opts?: {
@@ -8,9 +9,10 @@ export type Relaunch = (argv: string[], env: Record<string, string>, opts?: {
  * the exit code, printing to stdout/stderr. `bin.ts` and `create-mercury-agent`
  * both call it; the app commands look for the app from `cwd` and run docker
  * through `deps`; `relaunch` is how `create` hands over to a newer CLI. */
-export declare function main(argv: string[], { cwd, deps, relaunch, globalInstall, }?: {
+export declare function main(argv: string[], { cwd, deps, relaunch, globalInstall, run, }?: {
     cwd?: string;
     deps?: AppDeps;
     relaunch?: Relaunch;
     globalInstall?: boolean;
+    run?: Run;
 }): Promise<number>;

package/dist/src/wizard.d.ts

@@ -1,11 +1,13 @@
 import type { CreateArgs } from "./args.ts";
-/** The answers `renderApp` needs, apart from the package versions. */
+/** The answers `renderApp` needs, apart from the package versions, and the
+ * repository's origin (none when absent). */
 export type Answers = {
     name: string;
     assistantName: string;
     role: string;
     channels: string[];
     plugins: string[];
+    gitRemote?: string;
 };
 export declare const DEFAULT_ASSISTANT_NAME = "Mercury";
 export declare const DEFAULT_ROLE = "an internal assistant";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mercury-fw/cli",
-  "version": "0.29.4",
+  "version": "0.31.0",
   "type": "module",
   "license": "MIT",
   "repository": {
@@ -27,6 +27,11 @@
       "mercury-fw-source": "./src/main.ts",
       "types": "./dist/src/main.d.ts",
       "default": "./src/main.ts"
+    },
+    "./e2e": {
+      "mercury-fw-source": "./src/e2e/define.ts",
+      "types": "./dist/src/e2e/define.d.ts",
+      "default": "./src/e2e/define.ts"
     }
   },
   "scripts": {
@@ -36,16 +41,16 @@
   "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.29.4",
+    "@mercury-fw/core": "0.31.0",
     "commander": "^15.0.0"
   },
   "devDependencies": {
     "@mercury-fw/channel-google-chat": "0.1.3",
     "@mercury-fw/channel-http": "0.1.0",
-    "@mercury-fw/formatter": "0.29.4",
+    "@mercury-fw/formatter": "0.31.0",
     "@mercury-fw/plugin-atlassian-admin": "0.1.0",
     "@mercury-fw/plugin-bitbucket": "0.1.0",
-    "@mercury-fw/plugin-jira": "0.3.0",
+    "@mercury-fw/plugin-jira": "0.4.1",
     "@mercury-fw/typescript-config": "*",
     "@types/bun": "^1.4.2",
     "typescript": "^6.0.3"