@mercury-fw/cli 0.29.4 → 0.30.0

package/CHANGELOG.md

@@ -1,5 +1,18 @@
 # @mercury-fw/cli
 
+## 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

@@ -44,9 +44,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 +58,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

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/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.30.0",
   "type": "module",
   "license": "MIT",
   "repository": {
@@ -36,13 +36,13 @@
   "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.30.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.30.0",
     "@mercury-fw/plugin-atlassian-admin": "0.1.0",
     "@mercury-fw/plugin-bitbucket": "0.1.0",
     "@mercury-fw/plugin-jira": "0.3.0",

package/src/args.ts

@@ -15,7 +15,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. */
@@ -25,7 +31,10 @@ export type CreateOptions = {
   role?: string;
   channels?: string;
   plugins?: string;
+  gitRemote?: string;
   yes?: boolean;
+  install?: boolean;
+  git?: boolean;
 };
 
 /** A comma-separated list, trimmed, empty items dropped. */
@@ -37,11 +46,13 @@ const list = (value: string): string[] =>
 
 /** The answers in `folder` and `opts`, with only what was actually given. */
 export function toCreateArgs(folder: string, opts: CreateOptions): CreateArgs {
-  const args: CreateArgs = { dir: folder, yes: opts.yes ?? false };
+  const args: CreateArgs = { dir: folder, yes: opts.yes ?? false, install: opts.install ?? true, git: opts.git ?? true };
   if (opts.name !== undefined) args.name = opts.name;
   if (opts.assistantName !== undefined) args.assistantName = opts.assistantName;
   if (opts.role !== undefined) args.role = opts.role;
   if (opts.channels !== undefined) args.channels = list(opts.channels);
   if (opts.plugins !== undefined) args.plugins = list(opts.plugins);
+  // Blank is none, as in the wizard.
+  if (opts.gitRemote !== undefined && opts.gitRemote.trim() !== "") args.gitRemote = opts.gitRemote.trim();
   return args;
 }

package/src/finish.ts

@@ -0,0 +1,144 @@
+/**
+ * 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 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 const spawnRun: Run = async (argv, cwd, opts) => {
+  try {
+    if (opts?.live) {
+      const proc = Bun.spawn(argv, { cwd, stdin: "ignore", stdout: "inherit", stderr: "inherit" });
+      return { code: await proc.exited, output: "" };
+    }
+    const proc = Bun.spawn(argv, { cwd, stdin: "ignore", stdout: "pipe", stderr: "pipe" });
+    const [stdout, stderr, code] = await Promise.all([
+      new Response(proc.stdout).text(),
+      new Response(proc.stderr).text(),
+      proc.exited,
+    ]);
+    return { code, output: stdout + stderr };
+  } catch (err) {
+    return { code: 127, output: err instanceof Error ? err.message : String(err) };
+  }
+};
+
+/** Runs the steps after writing the app in `dir`; see the file's comment. */
+export async function finishApp(dir: string, opts: FinishOptions, run: Run): Promise<FinishReport> {
+  const report: FinishReport = { install: "off", git: "off", remote: "off" };
+  if (opts.install) {
+    // Live: an install can take a while, and its progress is worth seeing.
+    const installed = await run(["bun", "install"], dir, { live: true });
+    report.install = installed.code === 0 ? "done" : { failed: `exit code ${installed.code}` };
+  }
+  if (!opts.git) return report;
+
+  const skipped = await whyNoGit(dir, run);
+  if (skipped !== undefined) {
+    report.git = { skipped };
+    return report;
+  }
+  const commit = opts.commitMessage.flatMap((paragraph) => ["-m", paragraph]);
+  const steps: [label: string, argv: string[]][] = [
+    ["git init", ["git", "init", "-q", "-b", "main"]],
+    ["git add -A", ["git", "add", "-A"]],
+    ["git commit", ["git", "commit", "-q", ...commit]],
+  ];
+  for (const [label, argv] of steps) {
+    const step = await run(argv, dir);
+    if (step.code !== 0) {
+      report.git = { failed: `${label}: ${step.output.trim()}` };
+      return report;
+    }
+  }
+  report.git = "done";
+
+  if (opts.remote !== undefined) {
+    const added = await run(["git", "remote", "add", "origin", opts.remote], dir);
+    report.remote = added.code === 0 ? "done" : { failed: added.output.trim() };
+  }
+  return report;
+}
+
+/** Why the repository can't be created in `dir`, or undefined when it can.
+ * Whether git can commit (an identity, hooks, signing) is git's to say: the
+ * commit runs, and its refusal is reported as it is. */
+async function whyNoGit(dir: string, run: Run): Promise<string | undefined> {
+  if ((await run(["git", "--version"], dir)).code !== 0) return "git isn't installed";
+  // An app created inside a monorepo belongs to that repository, not a nested one.
+  if ((await run(["git", "rev-parse", "--is-inside-work-tree"], dir)).code === 0) return INSIDE_A_REPOSITORY;
+  return undefined;
+}
+
+/** `outcome` as a status line's value, or undefined for a step that was off. */
+function statusOf(outcome: FinishReport[keyof FinishReport], done: string): string | undefined {
+  if (outcome === "off") return undefined;
+  if (outcome === "done") return done;
+  if ("skipped" in outcome) return `skipped, ${outcome.skipped}`;
+  return `failed (${outcome.failed})`;
+}
+
+/** The command's closing output: where the app is, what the steps after
+ * writing did, and what's left to run. */
+export function finishMessage(app: { name: string; dir: string; remote?: string; report: FinishReport }): string {
+  const { report } = app;
+  const insideRepository = typeof report.git === "object" && "skipped" in report.git && report.git.skipped === INSIDE_A_REPOSITORY;
+  // A repository that git didn't finish (not installed, a step refused) is
+  // finished by hand; one skipped on purpose isn't.
+  const byHand = report.git !== "done" && report.git !== "off" && !insideRepository;
+  const status = [
+    ["bun install", statusOf(report.install, "done")],
+    ["git", statusOf(report.git, "first commit on main")],
+    ["origin", insideRepository && app.remote !== undefined ? "not added, the app is in that repository" : statusOf(report.remote, app.remote ?? "")],
+  ].flatMap(([step, value]) => (value === undefined ? [] : [`  ${step}: ${value}\n`]));
+
+  const next = [`cd ${app.dir}`];
+  if (report.install !== "done") next.push("bun install");
+  if (byHand) {
+    next.push("git init -b main", "git add -A", 'git commit -m "Scaffold with mfw create"');
+    if (app.remote !== undefined) next.push(`git remote add origin ${app.remote}`);
+  } else if (report.git === "done") {
+    if (report.install !== "done") next.push('git add bun.lock && git commit -m "Add bun.lock"');
+    if (app.remote !== undefined && report.remote !== "done") next.push(`git remote add origin ${app.remote}`);
+  }
+  next.push("cp .env.example .env    # then fill it in", "mfw start               # bunx mfw start, without a global mfw");
+  if (report.git === "done" && report.remote === "done") next.push("git push -u origin main");
+
+  return `Created ${app.name} in ${app.dir}
+${status.join("")}
+Next:
+${next.map((line) => `  ${line}\n`).join("")}
+Optional, to have mfw everywhere:
+  bun add -g @mercury-fw/cli
+`;
+}

package/src/main.ts

@@ -1,7 +1,7 @@
 /**
  * The `mfw` command. `create <folder>` writes a new Mercury app from the
  * template, asking what to put in it (or taking the answers from flags with
- * `--yes`); `bun install` in the new app is left to the user. The other
+ * `--yes`), then installs it and commits it to a new repository (`finish.ts`). The other
  * commands operate an existing app from inside its folder (see
  * `app/commands.ts`). The command line itself is declared in `program.ts`.
  */
@@ -16,6 +16,7 @@ import { appVersions, cliVersion, newerCli, registryFrom } from "./versions.ts";
 import { appCommands, terminalDeps, type AppDeps } from "./app/commands.ts";
 import { findApp, type App } from "./app/find-app.ts";
 import { askAnswers, DEFAULT_ASSISTANT_NAME, DEFAULT_ROLE, type Answers } from "./wizard.ts";
+import { finishApp, finishMessage, spawnRun, type Run } from "./finish.ts";
 import { targetError, writeApp } from "./write.ts";
 
 /** The answers taken from the flags alone, defaults for the rest. */
@@ -26,6 +27,7 @@ function answersFromFlags(args: CreateArgs, defaultName: string): Answers {
     role: args.role ?? DEFAULT_ROLE,
     channels: args.channels ?? [],
     plugins: args.plugins ?? [],
+    ...(args.gitRemote !== undefined ? { gitRemote: args.gitRemote } : {}),
   };
 }
 
@@ -90,9 +92,18 @@ async function relaunchIfStale(rawArgs: string[], relaunch: Relaunch, globalInst
   return relaunch(["bunx", cli, "create", ...rawArgs], env);
 }
 
+/** What's wrong with `--git-remote`, or undefined. It's taken as typed, but
+ * one starting with "-" would reach git as an option. */
+function remoteError(args: CreateArgs): string | undefined {
+  if (args.gitRemote === undefined) return undefined;
+  if (!args.git) return "--git-remote needs the repository: drop --no-git";
+  if (args.gitRemote.startsWith("-")) return `--git-remote "${args.gitRemote}" isn't a remote`;
+  return undefined;
+}
+
 /** `mfw create`: returns the exit code. `rawArgs` are the arguments after
  * `create` as typed, for a relaunch. */
-async function create(args: CreateArgs, rawArgs: string[], relaunch: Relaunch, globalInstall: boolean): Promise<number> {
+async function create(args: CreateArgs, rawArgs: string[], relaunch: Relaunch, globalInstall: boolean, run: Run): Promise<number> {
   const relaunched = await relaunchIfStale(rawArgs, relaunch, globalInstall);
   if (relaunched !== undefined) return relaunched;
   // The folder is created in kebab case, only its own name: the parent path is
@@ -105,7 +116,10 @@ async function create(args: CreateArgs, rawArgs: string[], relaunch: Relaunch, g
   const dir = join(dirname(typed), folder);
   // What the command line already settles is checked before any question, so
   // the wizard is never answered for nothing.
-  const early = targetError(dir) ?? selectionError(args.channels ?? [], args.plugins ?? []);
+  const early =
+    targetError(dir) ??
+    selectionError(args.channels ?? [], args.plugins ?? []) ??
+    remoteError(args);
   if (early !== undefined) {
     throw new Error(early);
   }
@@ -118,16 +132,21 @@ async function create(args: CreateArgs, rawArgs: string[], relaunch: Relaunch, g
   ).map((e) => e.package);
   const versions = await appVersions(chosen, { registry: registryFrom(process.env.MFW_REGISTRY) });
   writeApp(dir, renderApp({ ...answers, versions }));
-  console.log(`Created ${answers.name} in ${dir}
-
-Next:
-  cd ${dir}
-  bun install
-  cp .env.example .env    # then fill it in
-  mfw start               # bunx mfw start, without a global mfw
-
-Optional, to have mfw everywhere:
-  bun add -g @mercury-fw/cli`);
+  const none = (ids: string[]) => (ids.length > 0 ? ids.join(", ") : "none");
+  const report = await finishApp(
+    dir,
+    {
+      install: args.install,
+      git: args.git,
+      ...(answers.gitRemote !== undefined ? { remote: answers.gitRemote } : {}),
+      commitMessage: [
+        `Scaffold with mfw create ${cliVersion()}`,
+        `Channels: ${none(answers.channels)}\nPlugins: ${none(answers.plugins)}`,
+      ],
+    },
+    run,
+  );
+  process.stdout.write(finishMessage({ name: answers.name, dir, remote: answers.gitRemote, report }));
   return 0;
 }
 
@@ -203,13 +222,14 @@ export async function main(
     deps,
     relaunch = spawnRelaunch,
     globalInstall = isGlobalInstall(),
-  }: { cwd?: string; deps?: AppDeps; relaunch?: Relaunch; globalInstall?: boolean } = {},
+    run = spawnRun,
+  }: { cwd?: string; deps?: AppDeps; relaunch?: Relaunch; globalInstall?: boolean; run?: Run } = {},
 ): Promise<number> {
   const handedOver = await handOverToAppCli(argv, cwd, relaunch);
   if (handedOver !== undefined) return handedOver;
   const rawCreateArgs = argv.slice(argv.indexOf("create") + 1);
   return runProgram(argv, {
-    create: (args) => create(args, rawCreateArgs, relaunch, globalInstall),
+    create: (args) => create(args, rawCreateArgs, relaunch, globalInstall, run),
     upgrade: () => upgrade(relaunch),
     app: () => appCommands(findApp(cwd), deps ?? terminalDeps()),
   });

package/src/program.ts

@@ -50,7 +50,7 @@ function buildProgram(handlers: ProgramHandlers, result: { code: number }): Comm
     .command("create")
     .summary("writes a new Mercury app")
     .description(
-      "Writes a new Mercury app into <folder>, which has to be missing or empty (its own name is turned into kebab case). Without options it asks for the app name, the assistant's name and role, and which channels and tool plugins to include; then it writes mercury.config.ts for that selection, the persona (persona/identity.md, persona/tone.md), the service and REPL entrypoints, a Dockerfile, a compose file with Qdrant, and an env example listing every variable the app reads. Nothing is installed: run bun install in the new app.",
+      "Writes a new Mercury app into <folder>, which has to be missing or empty (its own name is turned into kebab case). Without options it asks for the app name, the assistant's name and role, and which channels and tool plugins to include; then it writes mercury.config.ts for that selection, the persona (persona/identity.md, persona/tone.md), the service and REPL entrypoints, a Dockerfile, a compose file with Qdrant, and an env example listing every variable the app reads. Then it runs bun install, and creates a git repository on main with a first commit, adding the origin when given (nothing is pushed).",
     )
     .argument("<folder>", "where to write the app")
     .option("--name <name>", "app name, as in package.json (default: the folder's name)")
@@ -61,6 +61,9 @@ function buildProgram(handlers: ProgramHandlers, result: { code: number }): Comm
       `comma-separated: ${CATALOG.filter((e) => e.kind === "channel").map((e) => e.id).join(", ")}`,
     )
     .option("--plugins <ids>", `comma-separated: ${CATALOG.filter((e) => e.kind === "tool").map((e) => e.id).join(", ")}`)
+    .option("--git-remote <url>", "the repository's origin, taken as typed (default: none)")
+    .option("--no-install", "don't run bun install")
+    .option("--no-git", "don't create the git repository")
     .option("-y, --yes", "don't ask: use the flags and the defaults")
     .addHelpText(
       "after",

package/src/wizard.ts

@@ -9,13 +9,15 @@ import { CATALOG, type CatalogEntry } from "./catalog.ts";
 import { appNameError } from "./render.ts";
 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 const DEFAULT_ASSISTANT_NAME = "Mercury";
@@ -67,6 +69,16 @@ export async function askAnswers(args: CreateArgs, dir: string): Promise<Answers
   if (channels === undefined) return cancelled();
   const plugins = await pick("tool", "Tool plugins (space to select)", args.plugins ?? []);
   if (plugins === undefined) return cancelled();
+  // Asked only when there will be a repository and the flag didn't say.
+  let gitRemote = args.gitRemote;
+  if (args.git && gitRemote === undefined) {
+    const typed = await p.text({
+      message: "Git remote for origin (empty: none, add it later)",
+      validate: (v) => (v?.trim().startsWith("-") ? "That's not a remote: git would read it as an option" : undefined),
+    });
+    if (p.isCancel(typed)) return cancelled();
+    if (typed && typed.trim()) gitRemote = typed.trim();
+  }
 
   p.note(
     [
@@ -74,12 +86,13 @@ export async function askAnswers(args: CreateArgs, dir: string): Promise<Answers
       `Assistant: You are ${assistantName}, ${role}.`,
       `Channels: ${channels.length > 0 ? channels.join(", ") : "none"}`,
       `Tool plugins: ${plugins.length > 0 ? plugins.join(", ") : "none"}`,
+      ...(args.git ? [`Origin: ${gitRemote ?? "none"}`] : []),
     ].join("\n"),
     "Summary",
   );
   const ok = await p.confirm({ message: `Create it in ${dir}?` });
   if (p.isCancel(ok) || !ok) return cancelled();
-  return { name, assistantName, role, channels, plugins };
+  return { name, assistantName, role, channels, plugins, ...(gitRemote !== undefined ? { gitRemote } : {}) };
 }
 
 function cancelled(): undefined {