@skillcdn/console 0.4.2 → 0.4.3

package/src/cli/cli.ts

@@ -5,6 +5,7 @@ import {
   type ConsoleClient,
   createClient,
   type FetchLike,
+  type FileUpload,
   type PluginClient,
   type ProjectClient,
 } from "../client.js";
@@ -2298,18 +2299,7 @@ const comment: Command = async (args, io) => {
   if (body.trim().length === 0 && paths.length === 0) {
     throw misuse(`Say something, or attach a file. ${ask}`);
   }
-  const files = [];
-  for (const path of paths) {
-    let bytes: Uint8Array;
-    try {
-      bytes = await io.readBytes(path);
-    } catch {
-      throw failed(`No file could be read at ${path}. Name the path of a file to attach.`);
-    }
-    const name = basename(path);
-    const contentType = CONTENT_TYPES[extname(name).toLowerCase()];
-    files.push({ name, bytes, ...(contentType === undefined ? {} : { contentType }) });
-  }
+  const files = await attachmentsOf(io, paths);
   const session = await open(io, values);
   const project = await session.project();
   const task = await project.task(ref);
@@ -2323,10 +2313,30 @@ const comment: Command = async (args, io) => {
   return EXIT.ok;
 };
 
+/**
+ * The files named by --attach, read from this machine: each called by its name, without the
+ * path, and typed by its extension where the extension says.
+ */
+async function attachmentsOf(io: CliIo, paths: readonly string[]): Promise<FileUpload[]> {
+  const files: FileUpload[] = [];
+  for (const path of paths) {
+    let bytes: Uint8Array;
+    try {
+      bytes = await io.readBytes(path);
+    } catch {
+      throw failed(`No file could be read at ${path}. Name the path of a file to attach.`);
+    }
+    const name = basename(path);
+    const contentType = CONTENT_TYPES[extname(name).toLowerCase()];
+    files.push({ name, bytes, ...(contentType === undefined ? {} : { contentType }) });
+  }
+  return files;
+}
+
 /**
  * A file of the project, read from the console and written on this machine: one a run handed
- * in, one put in a comment, or one attached to a page, by its id, so that an agent can look at
- * a picture a person put on the board.
+ * in, one put in a comment or on a decision, or one attached to a page, by its id, so that an
+ * agent can look at a picture a person put on the board.
  */
 const file: Command = async (args, io) => {
   const { values, positionals } = parse(args, { out: { type: "string" } });
@@ -2521,6 +2531,7 @@ const ask: Command = async (args, io) => {
     run: { type: "string" },
     wait: { type: "string" },
     to: { type: "string" },
+    attach: { type: "string", multiple: true },
   });
   const question = theOne(
     positionals,
@@ -2536,23 +2547,30 @@ const ask: Command = async (args, io) => {
   }
   const seconds = secondsOf(text(values, "wait"), DEFAULT_ASK_WAIT_SECONDS);
   const body = await bodyOf(io, values, text(values, "body"));
+  // The files put on the decision (ADR-0055): a picture of what is to be chosen between, for one.
+  const files = await attachmentsOf(io, texts(values, "attach"));
   const session = await open(io, values);
   const project = await session.project();
   const runId = await currentRun(project, values);
   // Whom the decision is for (ADR-0042): the person the agent works for, unless --to names another.
   const deciderId = await personIdOf(session, to);
-  const raised = await project.raiseDecision({
-    question,
-    options: options.map((label) => ({ label })),
-    runId,
-    ...(body === undefined ? {} : { body }),
-    ...(typeof deciderId === "string" ? { deciderId } : {}),
-  });
+  const raised = await project.raiseDecision(
+    {
+      question,
+      options: options.map((label) => ({ label })),
+      runId,
+      ...(body === undefined ? {} : { body }),
+      ...(typeof deciderId === "string" ? { deciderId } : {}),
+    },
+    files,
+  );
+  const withFiles =
+    files.length === 0 ? "" : `, with ${files.length} file${files.length === 1 ? "" : "s"}`;
   // The id is printed before any waiting, so that a wait cut short loses nothing.
   io.stdout(
     session.json
       ? `${JSON.stringify(raised, null, 2)}\n`
-      : `Decision ${raised.id} raised on run ${runId}; the run waits for ${raised.decider.login}.\ndecision id: ${raised.id}\n${formatOptions(raised)}\n`,
+      : `Decision ${raised.id} raised on run ${runId}${withFiles}; the run waits for ${raised.decider.login}.\ndecision id: ${raised.id}\n${formatOptions(raised)}\n`,
   );
   return settle(io, session, project, raised, seconds, true);
 };

package/src/cli/format.ts

@@ -445,7 +445,7 @@ export function formatOptions(decision: RestDecision): string {
   return decision.options
     .map(
       (option) =>
-        `  ${option.id}) ${option.label}${option.own === true ? "  (the person's own answer, not one given)" : ""}`,
+        `  ${option.id}) ${option.label}${option.key === undefined ? "" : `  [${option.key}]`}${option.own === true ? "  (the person's own answer, not one given)" : ""}`,
     )
     .join("\n");
 }
@@ -474,6 +474,17 @@ export function formatDecision(decision: RestDecision): string {
   if (decision.body.trim().length > 0) {
     lines.push("", decision.body.trimEnd());
   }
+  // The files put on it (ADR-0055), each with the command that reads it.
+  const files = decision.files ?? [];
+  if (files.length > 0) {
+    lines.push(
+      "",
+      ...files.map(
+        (attached) =>
+          `file: ${attached.file.name} (${attached.file.size} bytes, ${attached.file.contentType}): console file ${attached.id}`,
+      ),
+    );
+  }
   lines.push("", "options:", formatOptions(decision), "", formatAnswer(decision));
   if (decision.outcome !== null && decision.outcome.trim().length > 0) {
     lines.push("", "what followed:", indent(decision.outcome));

package/src/cli/help.ts

@@ -13,6 +13,7 @@ import {
   MAX_DOCUMENTS_PER_PROJECT,
   MAX_FILE_BYTES,
   MAX_FILES_PER_COMMENT,
+  MAX_FILES_PER_DECISION,
   MAX_FILES_PER_DOCUMENT,
   MAX_GOALS_PER_PROJECT,
   MAX_LINK_LABEL_LENGTH,
@@ -450,16 +451,18 @@ export const COMMAND_HELP: Readonly<Record<string, CommandHelp>> = {
   },
   ask: {
     usage:
-      'ask "<question>" --option "<label>" --option "<label>" [...] [--body <markdown>|--file <path>] [--to <login|me>] [--wait <seconds>] [--run <id>]',
+      'ask "<question>" --option "<label>" --option "<label>" [...] [--body <markdown>|--file <path>] [--attach <path>]... [--to <login|me>] [--wait <seconds>] [--run <id>]',
     overview:
-      'ask "<question>" --option "<label>" --option "<label>" [...] [--body <markdown>|--file <path>] [--to <login|me>] [--wait <seconds>]',
+      'ask "<question>" --option "<label>" --option "<label>" [...] [--body <markdown>|--file <path>] [--attach <path>]... [--to <login|me>] [--wait <seconds>]',
     synopsis:
       "Raises a decision a person must make, with options, and waits a while for the answer.",
-    about: `Raises a decision a person must make: the question, the options to choose from, and what they need to know. It is for the person you work for unless --to names another of the project, who then finds it among their decisions (ADR-0042); anyone of the project may still answer. The run waits for the answer. The command waits 60 seconds for it unless --wait says otherwise, and exits with 3 if it is still to come: keep waiting with \`console decision <id> --wait 100\`, within what your shell gives one command. The decision's id is printed as soon as it is raised. The person chooses one of the options, or answers in their own words: the answer then names one more option, their words, marked own; act on it as given. ${ON_THE_RUN}`,
+    about: `Raises a decision a person must make: the question, the options to choose from, and what they need to know. --attach puts a file on the decision, in the one request: a picture of what is to be chosen between, a screenshot of what was made; a picture the body names as ![words](its name) is shown there, the rest after the body, and the person reads each back with \`console file <id>\` (ADR-0055). It is for the person you work for unless --to names another of the project, who then finds it among their decisions (ADR-0042); anyone of the project may still answer. The run waits for the answer. The command waits 60 seconds for it unless --wait says otherwise, and exits with 3 if it is still to come: keep waiting with \`console decision <id> --wait 100\`, within what your shell gives one command. The decision's id is printed as soon as it is raised. The person chooses one of the options, or answers in their own words: the answer then names one more option, their words, marked own; act on it as given. ${ON_THE_RUN}`,
     limits: [
       `question: one line, up to ${MAX_QUESTION_LENGTH} characters`,
       `options: ${MIN_OPTIONS} to ${MAX_OPTIONS}, each one line up to ${MAX_OPTION_LABEL_LENGTH} characters`,
       `body: ${MARKDOWN}`,
+      `attach: a file: up to ${MAX_FILE_BYTES} bytes, not empty; called by its name, without the path; a picture is placed in the body as ![words](its name)`,
+      `at most ${MAX_FILES_PER_DECISION} files on one decision, together up to ${MAX_FILE_BYTES} bytes`,
       "to: a login of the project, or me",
       `at most ${MAX_DECISIONS_PER_PROJECT} decisions in one project`,
     ],
@@ -468,6 +471,8 @@ export const COMMAND_HELP: Readonly<Record<string, CommandHelp>> = {
       "decision.invalid_run: the run is not yours, or is over",
       "decision.invalid_decider: the person named may not work in the project",
       "decision.too_many: the project holds as many decisions as one may",
+      "decision.too_many_files: more files than one decision carries",
+      "request.too_large: a file, or the files together, over the bound",
     ],
   },
   answer: {
@@ -558,7 +563,7 @@ export const COMMAND_HELP: Readonly<Record<string, CommandHelp>> = {
     usage: "file <id> [--out <path>]",
     synopsis: "Reads a file of the project to this machine, by its id.",
     about:
-      "Reads a file of the project from the console and writes it on this machine: one a run handed in, one put in a comment, or one attached to a page, by the id the task, the run or the page shows. Written under its own name in the working directory, at --out <path>, or into --out <directory>. Then look at it with your own tools.",
+      "Reads a file of the project from the console and writes it on this machine: one a run handed in, one put in a comment or on a decision, or one attached to a page, by the id the task, the run, the decision or the page shows. Written under its own name in the working directory, at --out <path>, or into --out <directory>. Then look at it with your own tools.",
     refusals: ["file.not_found: no file of this project has that id"],
   },
   docs: {

package/src/cli/plugin-check.ts

@@ -13,6 +13,7 @@ import {
   parsePluginManifest,
 } from "../plugin/manifest.js";
 import { forbiddenImportsIn, removedGlobalsIn } from "../plugin/sandbox.js";
+import { isLanguageMap } from "./plugin-init.js";
 
 export interface CheckReport {
   readonly ok: boolean;
@@ -308,6 +309,27 @@ function describeCounts(manifest: PluginManifest, description: PluginDescription
   return counts.join(", ");
 }
 
+/**
+ * The words of the manifest, as JSON, whose translation repeats the English words (`name.ko`,
+ * for one): what `init --languages` copies for the author to translate, and what was left.
+ */
+export function sameAsEnglish(value: unknown, at = ""): string[] {
+  if (Array.isArray(value)) {
+    return value.flatMap((item, index) => sameAsEnglish(item, `${at}[${index}]`));
+  }
+  if (typeof value !== "object" || value === null) {
+    return [];
+  }
+  if (isLanguageMap(value)) {
+    return Object.entries(value)
+      .filter(([language, words]) => language !== "en" && words === value.en)
+      .map(([language]) => `${at}.${language}`.replace(/^\./, ""));
+  }
+  return Object.entries(value).flatMap(([key, inner]) =>
+    sameAsEnglish(inner, at.length === 0 ? key : `${at}.${key}`),
+  );
+}
+
 /** Reads the plugin at `root` as a console would, and says what it would refuse. */
 export async function checkPlugin(
   root: string,
@@ -338,6 +360,11 @@ export async function checkPlugin(
       `console-plugin.json: pluginApi ${manifest.pluginApi} is not one this command knows (${PLUGIN_API_MAJORS.join(", ")}); write against ${CURRENT_PLUGIN_API}`,
     );
   }
+  for (const path of sameAsEnglish(manifestRead.value)) {
+    warnings.push(
+      `console-plugin.json: ${path} is the same as en: translate it, or leave the language out`,
+    );
+  }
 
   const packageRead = await readJson(join(root, "package.json"));
   let version = "0.0.0";

package/src/cli/plugin-cli.ts

@@ -6,7 +6,7 @@ import { parseArgs } from "node:util";
 import type { ServerLoad } from "../plugin/load.js";
 import { isPluginKey, RESERVED_PLUGIN_KEYS } from "../plugin/manifest.js";
 import { checkPlugin } from "./plugin-check.js";
-import { nameFromKey, writePluginFromTemplate } from "./plugin-init.js";
+import { LANGUAGE_TAG, nameFromKey, PACKAGE_NAME, writePluginFromTemplate } from "./plugin-init.js";
 
 export interface PluginCliIo {
   stdout(text: string): void;
@@ -25,12 +25,20 @@ export const PLUGIN_EXIT = { ok: 0, failed: 1, usage: 2 } as const;
 export const PLUGIN_USAGE = `console-plugin: writes and checks a plugin of the SkillCDN Console.
 
   console-plugin init <dir> --key <key> [--name <name>] [--console <dependency>]
+      [--package <name>] [--repository <url> [--directory <path>]] [--languages <tags>]
       Writes a plugin into <dir>, which must not exist or be empty, from the template this
       package ships: the manifest, a server module with one collection, one command and one
       query, the source of a web bundle with one page and one widget, one skill with its
       manifest, tests, and the build. <key> is the plugin's key, lowercase letters, digits and
       hyphens; --name its name for people, from the key unless said; --console what the
-      plugin's devDependency on @skillcdn/console says, ^<this version> unless said.
+      plugin's devDependency on @skillcdn/console says, ^<this version> unless said;
+      --package the package's name, console-plugin-<key> unless said, a scoped one
+      (@scope/console-plugin-<key>) published as public; --repository the https address of
+      the repository it lives in, with --directory its path there in a repository of several,
+      which fill repository, homepage and bugs and the manifest's store; --languages the
+      languages of its words with commas between, en first (en,ko), each language map and
+      both manifests' translations given the others as English words to translate, of which
+      check warns while they stay English.
 
   console-plugin check [<dir>]
       Reads the plugin in <dir>, the working directory unless said, as a console would, built:
@@ -68,13 +76,32 @@ export async function runPluginCli(argv: readonly string[], io: PluginCliIo): Pr
   return PLUGIN_EXIT.usage;
 }
 
+const INIT_USAGE =
+  "usage: console-plugin init <dir> --key <key> [--name <name>] [--console <dependency>] [--package <name>] [--repository <url> [--directory <path>]] [--languages <tags>]\n";
+
 async function init(args: readonly string[], io: PluginCliIo): Promise<number> {
-  let values: { key?: string; name?: string; console?: string };
+  let values: {
+    key?: string;
+    name?: string;
+    console?: string;
+    package?: string;
+    repository?: string;
+    directory?: string;
+    languages?: string;
+  };
   let positionals: string[];
   try {
     ({ values, positionals } = parseArgs({
       args: [...args],
-      options: { key: { type: "string" }, name: { type: "string" }, console: { type: "string" } },
+      options: {
+        key: { type: "string" },
+        name: { type: "string" },
+        console: { type: "string" },
+        package: { type: "string" },
+        repository: { type: "string" },
+        directory: { type: "string" },
+        languages: { type: "string" },
+      },
       allowPositionals: true,
       strict: true,
     }));
@@ -85,8 +112,51 @@ async function init(args: readonly string[], io: PluginCliIo): Promise<number> {
   const [dir, ...extra] = positionals;
   const key = values.key;
   if (dir === undefined || extra.length > 0 || key === undefined) {
+    io.stderr(INIT_USAGE);
+    return PLUGIN_EXIT.usage;
+  }
+  const packageName = values.package;
+  if (packageName !== undefined && (packageName.length > 214 || !PACKAGE_NAME.test(packageName))) {
+    io.stderr(
+      `console-plugin init: ${packageName} is not a package name: lowercase letters, digits, hyphens, dots and underscores, with a scope as @scope/name\n`,
+    );
+    return PLUGIN_EXIT.usage;
+  }
+  if (values.directory !== undefined && values.repository === undefined) {
+    io.stderr("console-plugin init: --directory goes with --repository\n");
+    return PLUGIN_EXIT.usage;
+  }
+  if (values.repository !== undefined && !isRepositoryAddress(values.repository)) {
+    io.stderr(
+      `console-plugin init: ${values.repository} is not the https address of a repository\n`,
+    );
+    return PLUGIN_EXIT.usage;
+  }
+  if (
+    values.directory !== undefined &&
+    !/^[A-Za-z0-9._-]+(?:\/[A-Za-z0-9._-]+)*$/.test(values.directory)
+  ) {
     io.stderr(
-      "usage: console-plugin init <dir> --key <key> [--name <name>] [--console <dependency>]\n",
+      "console-plugin init: --directory is a path within the repository, with forward slashes\n",
+    );
+    return PLUGIN_EXIT.usage;
+  }
+  const languages = values.languages
+    ?.split(",")
+    .map((language) => language.trim())
+    .filter((language) => language.length > 0);
+  if (
+    languages !== undefined &&
+    (languages.length === 0 || languages.some((language) => !LANGUAGE_TAG.test(language)))
+  ) {
+    io.stderr(
+      "console-plugin init: --languages is a list of language tags with commas between, en first: en,ko\n",
+    );
+    return PLUGIN_EXIT.usage;
+  }
+  if (languages !== undefined && languages[0] !== "en") {
+    io.stderr(
+      "console-plugin init: --languages begins with en, the language the template is written in\n",
     );
     return PLUGIN_EXIT.usage;
   }
@@ -112,6 +182,12 @@ async function init(args: readonly string[], io: PluginCliIo): Promise<number> {
       key,
       name,
       consoleDependency,
+      packageName,
+      repository:
+        values.repository === undefined
+          ? undefined
+          : { url: values.repository, directory: values.directory },
+      languages,
     });
     io.stdout(`Wrote the plugin ${key} into ${target}: ${written.length} files.\n`);
     io.stdout(
@@ -124,6 +200,19 @@ async function init(args: readonly string[], io: PluginCliIo): Promise<number> {
   }
 }
 
+/** An https address of a repository, as git names it or as a browser opens it. */
+function isRepositoryAddress(value: string): boolean {
+  const address = value.replace(/^git\+/, "");
+  if (!/^https:\/\/\S+$/.test(address)) {
+    return false;
+  }
+  try {
+    return new URL(address).hostname.length > 0;
+  } catch {
+    return false;
+  }
+}
+
 async function check(args: readonly string[], io: PluginCliIo): Promise<number> {
   const [dir, ...extra] = args;
   if (extra.length > 0 || dir?.startsWith("-")) {

package/src/cli/plugin-init.ts

@@ -1,7 +1,9 @@
 // `console-plugin init` (docs/specs/plugins.md, "Authoring"): writes a plugin from the template
-// the package ships, the words `__key__`, `__name__` and `__console__` in the template's files and
-// their names replaced. `examples/plugin-hello` in the console's repository is what it writes for
-// the key `hello`, and a test holds the two equal.
+// the package ships, the words `__package__`, `__key__`, `__name__` and `__console__` in the
+// template's files and their names replaced; then what the template cannot say in a word, where
+// it was asked for: the fields a published or a repository-bound package carries, and the
+// languages beyond English. `examples/plugin-hello` in the console's repository is what it writes
+// for the key `hello` with nothing else said, and a test holds the two equal.
 import { mkdir, readdir, readFile, stat, writeFile } from "node:fs/promises";
 import { join, relative, sep } from "node:path";
 
@@ -11,11 +13,31 @@ export interface InitOptions {
   readonly name: string;
   /** What the plugin's devDependency on `@skillcdn/console` says: `^<version>` of the command, unless said. */
   readonly consoleDependency: string;
+  /** The package's name: `console-plugin-<key>` unless said. A scoped name is published with `publishConfig.access` `public`. */
+  readonly packageName?: string | undefined;
+  /** The repository the plugin lives in and, in a repository of several, its directory: `repository`, `homepage`, `bugs` and the manifest's `store`. */
+  readonly repository?:
+    | { readonly url: string; readonly directory?: string | undefined }
+    | undefined;
+  /** The languages the plugin's words are in, `en` first; `en` alone unless said. Every language map and both manifests' translations get the others, copied from English for the author to translate. */
+  readonly languages?: readonly string[] | undefined;
+}
+
+/** A language tag as the manifest's language maps are keyed: `en`, `ko`, `pt-BR`. */
+export const LANGUAGE_TAG = /^[a-z]{2,3}(?:-[A-Za-z0-9]+)*$/;
+
+/** A package's name as the registry takes one: lowercase, with a scope as `@scope/name`. */
+export const PACKAGE_NAME = /^(?:@[a-z0-9][a-z0-9._-]*\/)?[a-z0-9][a-z0-9._-]*$/;
+
+/** The package's name from the options: what was said, else `console-plugin-<key>`. */
+export function packageNameOf(options: InitOptions): string {
+  return options.packageName ?? `console-plugin-${options.key}`;
 }
 
 /** The words the template uses, and what each becomes. */
 export function substitutions(options: InitOptions): readonly [string, string][] {
   return [
+    ["__package__", packageNameOf(options)],
     ["__key__", options.key],
     ["__name__", options.name],
     ["__console__", options.consoleDependency],
@@ -86,5 +108,150 @@ export async function writePluginFromTemplate(
     await writeFile(path, substitute(text, options), "utf8");
     written.push(target);
   }
+  await adaptPlugin(targetDir, options);
   return written;
 }
+
+/** Whether a value of the manifest is a language map: words per language, `en` among them. */
+export function isLanguageMap(value: unknown): value is Record<string, string> {
+  return (
+    typeof value === "object" &&
+    value !== null &&
+    !Array.isArray(value) &&
+    "en" in value &&
+    Object.entries(value).every(
+      ([language, words]) => LANGUAGE_TAG.test(language) && typeof words === "string",
+    )
+  );
+}
+
+/** Every language map of the manifest, wherever it is, gets `languages`, each copied from English where it is missing. */
+function addLanguages(value: unknown, languages: readonly string[]): void {
+  if (Array.isArray(value)) {
+    for (const item of value) {
+      addLanguages(item, languages);
+    }
+    return;
+  }
+  if (typeof value !== "object" || value === null) {
+    return;
+  }
+  if (isLanguageMap(value)) {
+    const english = value.en ?? "";
+    for (const language of languages) {
+      if (!(language in value)) {
+        value[language] = english;
+      }
+    }
+    return;
+  }
+  for (const inner of Object.values(value)) {
+    addLanguages(inner, languages);
+  }
+}
+
+/** The page of a repository at its host, from the address git names it by. */
+function pageOf(url: string): string {
+  return url
+    .replace(/^git\+/, "")
+    .replace(/\.git$/, "")
+    .replace(/\/$/, "");
+}
+
+/**
+ * The manifest's front-matter with `translations` for `languages`, each the English words
+ * again, inserted before the front-matter's end; under `parent` where the format nests them
+ * (`skillcdn.translations` in a skill). The description is the one the front-matter has, as
+ * written; the title is the plugin's name.
+ */
+function withTranslations(
+  text: string,
+  languages: readonly string[],
+  titleKey: "name" | "title",
+  title: string,
+  parent?: "skillcdn",
+): string {
+  const newline = text.includes("\r\n") ? "\r\n" : "\n";
+  const lines = text.split(/\r?\n/);
+  const end = lines.indexOf("---", 1);
+  if (lines[0] !== "---" || end === -1) {
+    return text;
+  }
+  const described = lines
+    .slice(1, end)
+    .find((line) => line.startsWith("description:"))
+    ?.slice("description:".length)
+    .trim();
+  const indent = parent === undefined ? "" : "  ";
+  const block = [
+    ...(parent === undefined ? [] : [`${parent}:`]),
+    `${indent}translations:`,
+    ...languages.flatMap((language) => [
+      `${indent}  ${language}:`,
+      `${indent}    ${titleKey}: ${JSON.stringify(title)}`,
+      ...(described === undefined ? [] : [`${indent}    description: ${described}`]),
+    ]),
+  ];
+  return [...lines.slice(0, end), ...block, ...lines.slice(end)].join(newline);
+}
+
+/**
+ * What the template cannot say in a word, where it was asked for: `publishConfig` for a scoped
+ * name, `repository`, `homepage` and `bugs` with the manifest's `store` for a repository, and
+ * the languages beyond English in every language map and both manifests' translations, each
+ * copied from the English words for the author to translate (`console-plugin check` warns of
+ * one left as it was). Nothing is rewritten when nothing was asked, so that the example stays
+ * what the template says.
+ */
+async function adaptPlugin(targetDir: string, options: InitOptions): Promise<void> {
+  const name = packageNameOf(options);
+  const repository = options.repository;
+  const languages = (options.languages ?? []).filter((language) => language !== "en");
+  if (!name.startsWith("@") && repository === undefined && languages.length === 0) {
+    return;
+  }
+  const packagePath = join(targetDir, "package.json");
+  const pkg = JSON.parse(await readFile(packagePath, "utf8")) as Record<string, unknown>;
+  const manifestPath = join(targetDir, "console-plugin.json");
+  const manifest = JSON.parse(await readFile(manifestPath, "utf8")) as Record<string, unknown>;
+  if (name.startsWith("@")) {
+    pkg.publishConfig = { access: "public" };
+  }
+  if (repository !== undefined) {
+    const page = pageOf(repository.url);
+    // The paths a git host has for a directory and for issues are the host's; only the one
+    // whose paths are known gets them.
+    const atGitHub = new URL(page).hostname === "github.com";
+    const homepage =
+      repository.directory !== undefined && atGitHub
+        ? `${page}/tree/HEAD/${repository.directory}`
+        : page;
+    pkg.repository = {
+      type: "git",
+      url: repository.url,
+      ...(repository.directory === undefined ? {} : { directory: repository.directory }),
+    };
+    pkg.homepage = homepage;
+    if (atGitHub) {
+      pkg.bugs = { url: `${page}/issues` };
+    }
+    manifest.store = { homepage, repository: page };
+  }
+  if (languages.length > 0) {
+    addLanguages(manifest, languages);
+    const skillcdn = join(targetDir, "SKILLCDN.md");
+    await writeFile(
+      skillcdn,
+      withTranslations(await readFile(skillcdn, "utf8"), languages, "name", options.name),
+      "utf8",
+    );
+    const skill = join(targetDir, "skills", options.key, "SKILL.md");
+    await writeFile(
+      skill,
+      withTranslations(await readFile(skill, "utf8"), languages, "title", options.name, "skillcdn"),
+      "utf8",
+    );
+  }
+  await writeFile(packagePath, `${JSON.stringify(pkg, null, 2)}\n`, "utf8");
+  await writeFile(manifestPath, `${JSON.stringify(manifest, null, 2)}\n`, "utf8");
+}

package/src/client.ts

@@ -325,7 +325,8 @@ export interface ProjectClient {
    * while the decision waits, for as long as it allows, and answers the decision as it stands.
    */
   awaitDecision(id: string, waitSeconds: number, signal?: AbortSignal): Promise<RestDecision>;
-  raiseDecision(input: RestDecisionInput): Promise<RestDecision>;
+  /** Raises a decision; with `files`, the files put on it (ADR-0055) go in the one request. */
+  raiseDecision(input: RestDecisionInput, files?: readonly FileUpload[]): Promise<RestDecision>;
   answerDecision(id: string, input: RestAnswerInput): Promise<RestDecision>;
   /** Grows a decision's record: its context, or what followed. */
   updateDecision(id: string, patch: RestDecisionPatch): Promise<RestDecision>;
@@ -343,7 +344,7 @@ export interface ProjectClient {
   handIn(runId: string, input: RestArtifactInput): Promise<RestRun>;
   /** Hands in a file, on a run of the asker's: the console keeps the bytes. */
   handInFile(runId: string, input: FileUpload): Promise<RestRun>;
-  /** Where the bytes of a file of the project are read, by its id: handed in by a run, put in a comment, or attached to a page. */
+  /** Where the bytes of a file of the project are read, by its id: handed in by a run, put in a comment or on a decision, or attached to a page. */
   fileUrl(fileId: string): string;
   /** The bytes of a file of the project, by its id, with the name and the type the console says. */
   readFile(fileId: string, signal?: AbortSignal): Promise<FileRead>;
@@ -774,11 +775,9 @@ export function createClient(options: ClientOptions = {}): ConsoleClient {
     return form;
   };
 
-  /** A comment with files as the parts of a form: the part `body`, and a part `file` for each file. */
-  const commentFormOf = (input: CommentInput): FormData => {
-    const form = new FormData();
-    form.set("body", input.body);
-    for (const file of input.files ?? []) {
+  /** The files appended to a form, a part `file` each, with its name and its type. */
+  const appendFiles = (form: FormData, files: readonly FileUpload[]): void => {
+    for (const file of files) {
       const bytes =
         file.bytes instanceof Blob ? file.bytes : new Blob([Uint8Array.from(file.bytes)]);
       form.append(
@@ -787,6 +786,21 @@ export function createClient(options: ClientOptions = {}): ConsoleClient {
         file.name,
       );
     }
+  };
+
+  /** A comment with files as the parts of a form: the part `body`, and a part `file` for each file. */
+  const commentFormOf = (input: CommentInput): FormData => {
+    const form = new FormData();
+    form.set("body", input.body);
+    appendFiles(form, input.files ?? []);
+    return form;
+  };
+
+  /** A decision with files as the parts of a form (ADR-0055): the part `decision`, what the JSON would say, and a part `file` for each file. */
+  const decisionFormOf = (input: RestDecisionInput, files: readonly FileUpload[]): FormData => {
+    const form = new FormData();
+    form.set("decision", JSON.stringify(input));
+    appendFiles(form, files);
     return form;
   };
 
@@ -860,8 +874,13 @@ export function createClient(options: ClientOptions = {}): ConsoleClient {
           restDecisionSchema,
           signal,
         ),
-      raiseDecision: (input) =>
-        request("POST", `${base}${at("decisions")}`, input, restDecisionSchema),
+      raiseDecision: (input, files = []) =>
+        request(
+          "POST",
+          `${base}${at("decisions")}`,
+          files.length > 0 ? decisionFormOf(input, files) : input,
+          restDecisionSchema,
+        ),
       answerDecision: (id, input) =>
         request("POST", `${base}${at("decisions", id)}/answer`, input, restDecisionSchema),
       updateDecision: (id, patch) =>

package/src/components/comments.tsx

@@ -305,6 +305,7 @@ export function TaskThread(props: TaskThreadProps) {
         decision={item.decision}
         task={props.task}
         docHref={props.docHref}
+        fileHref={fileHref}
         onAnswer={props.onAnswer}
         onUpdate={props.onUpdateDecision}
         busy={props.busy}