@sweetener/cli 0.1.0-alpha.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Jimmy Miller
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,16 @@
+# @sweetener/cli
+
+Check, build, and watch a Sweetener project, and scaffold one into an existing repository.
+
+Part of [Sweetener](https://github.com/sweetener-ts/sweetener), hygienic
+declarative macros for TypeScript. Alpha: the language version is 1 and the
+package interfaces may still change.
+
+## Usage
+
+```sh
+npx sweetener init          # scaffold, after showing what it would write
+npx sweetener check         # type-check through the official compiler
+npx sweetener build         # expand and emit
+npx sweetener watch
+```

package/bin/sweetener.mjs

@@ -0,0 +1,29 @@
+#!/usr/bin/env node
+// The `sweetener` command, kept in the repository rather than generated.
+//
+// A package manager creates the link for a command while it installs, and in
+// this workspace nothing is built at that point, so a link pointing straight
+// into `dist/` could not be created and every example that runs `sweetener`
+// was left with no such command. This file always exists, so the link always
+// can be, and running it before a build says so plainly.
+import { existsSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath, pathToFileURL } from "node:url";
+
+const entry = join(
+  dirname(fileURLToPath(import.meta.url)),
+  "..",
+  "dist",
+  "src",
+  "bin.js",
+);
+
+if (!existsSync(entry)) {
+  process.stderr.write(
+    `@sweetener/cli has not been built: ${entry} does not exist.\n` +
+      `Run \`pnpm build\` in the repository root, then try again.\n`,
+  );
+  process.exit(1);
+}
+
+await import(pathToFileURL(entry).href);

package/dist/src/bin.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+export {};
+//# sourceMappingURL=bin.d.ts.map

package/dist/src/bin.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bin.d.ts","sourceRoot":"","sources":["../../src/bin.ts"],"names":[],"mappings":""}

package/dist/src/bin.js

@@ -0,0 +1,45 @@
+#!/usr/bin/env node
+import { readSync } from "node:fs";
+import { runCli } from "./command-line.js";
+/**
+ * Reads one line of an answer from the terminal.
+ *
+ * Synchronous because the commands are, and reading a byte at a time because
+ * anything buffered would swallow input the shell still needs afterwards.
+ */
+function askOnTerminal(question) {
+    if (!process.stdin.isTTY)
+        return false;
+    process.stdout.write(question);
+    const byte = Buffer.alloc(1);
+    let answer = "";
+    for (;;) {
+        let read;
+        try {
+            read = readSync(0, byte, 0, 1, null);
+        }
+        catch {
+            return false;
+        }
+        if (read === 0)
+            break;
+        const character = byte.toString("utf8");
+        if (character === "\n" || character === "\r")
+            break;
+        answer += character;
+    }
+    process.stdout.write("\n");
+    return /^y(?:es)?$/iu.test(answer.trim());
+}
+const result = runCli({
+    argv: process.argv.slice(2),
+    io: {
+        stdout: (text) => process.stdout.write(text),
+        stderr: (text) => process.stderr.write(text),
+        // Only where there is a terminal to answer. Everywhere else a command that
+        // would write says so and stops, rather than taking silence for consent.
+        ...(process.stdin.isTTY ? { confirm: askOnTerminal } : {}),
+    },
+});
+process.exitCode = result.exitCode;
+//# sourceMappingURL=bin.js.map

package/dist/src/bin.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"bin.js","sourceRoot":"","sources":["../../src/bin.ts"],"names":[],"mappings":";AACA,OAAO,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AACnC,OAAO,EAAE,MAAM,EAAE,MAAM,mBAAmB,CAAC;AAE3C;;;;;GAKG;AACH,SAAS,aAAa,CAAC,QAAgB;IACrC,IAAI,CAAC,OAAO,CAAC,KAAK,CAAC,KAAK;QAAE,OAAO,KAAK,CAAC;IACvC,OAAO,CAAC,MAAM,CAAC,KAAK,CAAC,QAAQ,CAAC,CAAC;IAC/B,MAAM,IAAI,GAAG,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;IAC7B,IAAI,MAAM,GAAG,EAAE,CAAC;IAChB,SAAS,CAAC;QACR,IAAI,IAAY,CAAC;QACjB,IAAI,CAAC;YACH,IAAI,GAAG,QAAQ,CAAC,CAAC,EAAE,IAAI,EAAE,CAAC,EAAE,CAAC,EAAE,IAAI,CAAC,CAAC;QACvC,CAAC;QAAC,MAAM,CAAC;YACP,OAAO,KAAK,CAAC;QACf,CAAC;QACD,IAAI,IAAI,KAAK,CAAC;YAAE,MAAM;QACtB,MAAM,SAAS,GAAG,IAAI,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAC;QACxC,IAAI,SAAS,KAAK,IAAI,IAAI,SAAS,KAAK,IAAI;YAAE,MAAM;QACpD,MAAM,IAAI,SAAS,CAAC;IACtB,CAAC;IACD,OAAO,CAAC,MAAM,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;IAC3B,OAAO,cAAc,CAAC,IAAI,CAAC,MAAM,CAAC,IAAI,EAAE,CAAC,CAAC;AAC5C,CAAC;AAED,MAAM,MAAM,GAAG,MAAM,CAAC;IACpB,IAAI,EAAE,OAAO,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC;IAC3B,EAAE,EAAE;QACF,MAAM,EAAE,CAAC,IAAI,EAAE,EAAE,CAAC,OAAO,CAAC,MAAM,CAAC,KAAK,CAAC,IAAI,CAAC;QAC5C,MAAM,EAAE,CAAC,IAAI,EAAE,EAAE,CAAC,OAAO,CAAC,MAAM,CAAC,KAAK,CAAC,IAAI,CAAC;QAC5C,2EAA2E;QAC3E,yEAAyE;QACzE,GAAG,CAAC,OAAO,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,OAAO,EAAE,aAAa,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;KAC3D;CACF,CAAC,CAAC;AAEH,OAAO,CAAC,QAAQ,GAAG,MAAM,CAAC,QAAQ,CAAC"}

package/dist/src/command-line.d.ts

@@ -0,0 +1,48 @@
+import type { System } from "typescript";
+import { type ProjectExpansionProvider, type WatchProject } from "./project-command.js";
+import { type ExpansionInspectionProvider } from "./expansion-tools.js";
+export interface CliIo {
+    readonly stdout: (text: string) => void;
+    readonly stderr: (text: string) => void;
+    /**
+     * Asks before anything is written. Absent when there is nobody to ask, in
+     * which case a command that would write refuses instead of assuming.
+     */
+    readonly confirm?: ((question: string) => boolean) | undefined;
+}
+export type CliInvocation = {
+    readonly command: "check" | "build" | "watch";
+    readonly configPath: string;
+    readonly debug: boolean;
+} | {
+    readonly command: "init";
+    readonly directory: string;
+    readonly assumeYes: boolean;
+} | {
+    readonly command: "expand";
+    readonly fileName: string;
+    readonly configPath?: string | undefined;
+} | {
+    readonly command: "explain";
+    readonly position: string;
+    readonly configPath?: string | undefined;
+    readonly json?: boolean | undefined;
+} | {
+    readonly command: "help";
+} | {
+    readonly command: "emit";
+    readonly fileNames: readonly string[];
+    readonly outDir: string;
+};
+export declare function parseCliInvocation(argv: readonly string[]): CliInvocation;
+export declare function runCli(options: {
+    readonly argv: readonly string[];
+    readonly expansionProvider?: ProjectExpansionProvider | undefined;
+    readonly inspectionProvider?: ExpansionInspectionProvider | undefined;
+    readonly io: CliIo;
+    readonly system?: System;
+}): {
+    readonly exitCode: 0 | 1;
+    readonly watch?: WatchProject;
+};
+//# sourceMappingURL=command-line.d.ts.map

package/dist/src/command-line.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"command-line.d.ts","sourceRoot":"","sources":["../../src/command-line.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,YAAY,CAAC;AAEzC,OAAO,EAGL,KAAK,wBAAwB,EAC7B,KAAK,YAAY,EAClB,MAAM,sBAAsB,CAAC;AAC9B,OAAO,EAKL,KAAK,2BAA2B,EACjC,MAAM,sBAAsB,CAAC;AAK9B,MAAM,WAAW,KAAK;IACpB,QAAQ,CAAC,MAAM,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,CAAC;IACxC,QAAQ,CAAC,MAAM,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,CAAC;IACxC;;;OAGG;IACH,QAAQ,CAAC,OAAO,CAAC,EAAE,CAAC,CAAC,QAAQ,EAAE,MAAM,KAAK,OAAO,CAAC,GAAG,SAAS,CAAC;CAChE;AAED,MAAM,MAAM,aAAa,GACrB;IACE,QAAQ,CAAC,OAAO,EAAE,OAAO,GAAG,OAAO,GAAG,OAAO,CAAC;IAC9C,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,KAAK,EAAE,OAAO,CAAC;CACzB,GACD;IACE,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,SAAS,EAAE,OAAO,CAAC;CAC7B,GACD;IACE,QAAQ,CAAC,OAAO,EAAE,QAAQ,CAAC;IAC3B,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,UAAU,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;CAC1C,GACD;IACE,QAAQ,CAAC,OAAO,EAAE,SAAS,CAAC;IAC5B,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,UAAU,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IACzC,QAAQ,CAAC,IAAI,CAAC,EAAE,OAAO,GAAG,SAAS,CAAC;CACrC,GACD;IAAE,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAA;CAAE,GAC5B;IACE,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,SAAS,EAAE,SAAS,MAAM,EAAE,CAAC;IACtC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;CACzB,CAAC;AA6BN,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,SAAS,MAAM,EAAE,GAAG,aAAa,CA6FzE;AAoJD,wBAAgB,MAAM,CAAC,OAAO,EAAE;IAC9B,QAAQ,CAAC,IAAI,EAAE,SAAS,MAAM,EAAE,CAAC;IACjC,QAAQ,CAAC,iBAAiB,CAAC,EAAE,wBAAwB,GAAG,SAAS,CAAC;IAClE,QAAQ,CAAC,kBAAkB,CAAC,EAAE,2BAA2B,GAAG,SAAS,CAAC;IACtE,QAAQ,CAAC,EAAE,EAAE,KAAK,CAAC;IACnB,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC;CAC1B,GAAG;IAAE,QAAQ,CAAC,QAAQ,EAAE,CAAC,GAAG,CAAC,CAAC;IAAC,QAAQ,CAAC,KAAK,CAAC,EAAE,YAAY,CAAA;CAAE,CA0P9D"}

package/dist/src/command-line.js

@@ -0,0 +1,449 @@
+import { existsSync, readFileSync } from "node:fs";
+import { resolve } from "node:path";
+import { scaffoldIntoProject, scaffoldProject, writeScaffold, } from "./scaffold.js";
+import * as ts from "typescript";
+import { runConfiguredProjectCommand, watchConfiguredProject, } from "./project-command.js";
+import { expansionView, explainOriginalPosition, parseSourcePosition, sourceOffset, } from "./expansion-tools.js";
+import { createDefaultProjectExpansionProvider } from "./default-expansion-provider.js";
+import { loadSweetProject } from "./configuration.js";
+import { emitStandalone } from "./standalone-emit.js";
+/**
+ * Pull `-p`/`--project` out of an argument list.
+ *
+ * `expand` and `explain` used to reject it, and only ever discovered a
+ * `tsconfig.json`. `init` writes `sweetener.json`, so in a scaffolded project
+ * two of the commands could not read the config the other four were using.
+ */
+function splitProjectOption(argv) {
+    const positional = [];
+    let configPath;
+    for (let index = 0; index < argv.length; index += 1) {
+        const argument = argv[index];
+        if (argument === "-p" || argument === "--project") {
+            const value = argv[++index];
+            if (value === undefined)
+                throw new TypeError(`${argument} requires a path`);
+            configPath = value;
+        }
+        else if (argument.startsWith("-"))
+            throw new TypeError(`Unknown argument ${argument}`);
+        else
+            positional.push(argument);
+    }
+    return { positional: Object.freeze(positional), configPath };
+}
+export function parseCliInvocation(argv) {
+    const command = argv[0];
+    if (command === "init") {
+        const rest = argv.slice(1);
+        const assumeYes = rest.some((argument) => argument === "--yes" || argument === "-y");
+        const directories = rest.filter((argument) => argument !== "--yes" && argument !== "-y");
+        if (directories.length > 1)
+            throw new TypeError("init takes at most one directory");
+        return Object.freeze({
+            command,
+            directory: directories[0] ?? ".",
+            assumeYes,
+        });
+    }
+    if (command === undefined ||
+        command === "--help" ||
+        command === "-h" ||
+        command === "help")
+        return Object.freeze({ command: "help" });
+    if (command === "expand") {
+        const { positional, configPath } = splitProjectOption(argv.slice(1));
+        if (positional.length !== 1)
+            throw new TypeError("expand requires one source file");
+        return Object.freeze({
+            command,
+            fileName: positional[0],
+            ...(configPath === undefined ? {} : { configPath }),
+        });
+    }
+    if (command === "emit") {
+        const fileNames = [];
+        let outDir;
+        for (let index = 1; index < argv.length; index += 1) {
+            const argument = argv[index];
+            if (argument === "--out-dir") {
+                const value = argv[++index];
+                if (value === undefined)
+                    throw new TypeError("--out-dir requires a directory");
+                outDir = value;
+            }
+            else if (argument.startsWith("-"))
+                throw new TypeError(`Unknown argument ${argument}`);
+            else
+                fileNames.push(argument);
+        }
+        if (fileNames.length === 0)
+            throw new TypeError("emit requires at least one source file");
+        // Required rather than defaulted to the source directory: a file that
+        // opted in with a directive keeps its own name, so emitting alongside it
+        // would overwrite the input.
+        if (outDir === undefined)
+            throw new TypeError("emit requires --out-dir");
+        return Object.freeze({
+            command,
+            fileNames: Object.freeze(fileNames),
+            outDir,
+        });
+    }
+    if (command === "explain") {
+        const json = argv.includes("--json");
+        const { positional, configPath } = splitProjectOption(argv.slice(1).filter((argument) => argument !== "--json"));
+        if (positional.length !== 1)
+            throw new TypeError("explain requires one file:line:column position");
+        parseSourcePosition(positional[0]);
+        return Object.freeze({
+            command,
+            position: positional[0],
+            ...(configPath === undefined ? {} : { configPath }),
+            ...(json ? { json } : {}),
+        });
+    }
+    if (command !== "check" && command !== "build" && command !== "watch")
+        throw new TypeError("Expected init, check, build, watch, expand, explain, or emit command");
+    let configPath = "tsconfig.json";
+    let debug = false;
+    for (let index = 1; index < argv.length; index++) {
+        const argument = argv[index];
+        if (argument === "--debug")
+            debug = true;
+        else if (argument === "-p" || argument === "--project") {
+            const value = argv[++index];
+            if (value === undefined)
+                throw new TypeError(`${argument} requires a path`);
+            configPath = value;
+        }
+        else
+            throw new TypeError(`Unknown argument ${argument}`);
+    }
+    return Object.freeze({ command, configPath, debug });
+}
+function at(file, start) {
+    const position = file.getLineAndCharacterOfPosition(start);
+    return `${file.fileName}:${String(position.line + 1)}:${String(position.character + 1)}`;
+}
+function renderDiagnostic(diagnostic) {
+    const message = ts.flattenDiagnosticMessageText(diagnostic.messageText, "\n");
+    const head = diagnostic.file === undefined || diagnostic.start === undefined
+        ? `TS${String(diagnostic.code)}: ${message}`
+        : `${at(diagnostic.file, diagnostic.start)} TS${String(diagnostic.code)}: ${message}`;
+    // A diagnostic that points somewhere else as well — the rule that wanted
+    // different syntax, the binding already holding a name — is most of the
+    // answer, and printing only the first line threw that away.
+    const related = (diagnostic.relatedInformation ?? []).map((entry) => {
+        const text = ts.flattenDiagnosticMessageText(entry.messageText, "\n");
+        return entry.file === undefined || entry.start === undefined
+            ? `  ${text}`
+            : `  ${at(entry.file, entry.start)} ${text}`;
+    });
+    return [head, ...related].join("\n");
+}
+const usage = `sweetener — hygienic declarative macros for TypeScript
+
+Usage: sweetener <command> [options]
+
+Commands:
+  init [directory]        Scaffold a project. Shows what it would write; pass
+                          --yes to write it.
+  check                   Type-check the project through the official compiler.
+  build                   Check, then expand and emit.
+  watch                   Rebuild as sources and macros change.
+  expand <file>           Print the expanded TypeScript for one source.
+  explain <file:line:col> Report where a position came from, and through which
+                          macros.
+  emit <files...>         Expand named files into a directory, without checking.
+
+Options:
+  -p, --project <path>    Project config to use. Defaults to the nearest
+                          tsconfig.json; \`init\` writes sweetener.json, so pass
+                          it here.
+  --yes, -y               For init: write the files rather than listing them.
+  --out-dir <dir>         For emit: where to write. Required.
+  --json                  For explain: print the raw origin records instead of
+                          a description.
+  --debug                 Print the expansion's internal state after the run.
+  -h, --help              Show this.
+`;
+/** One-based line and column for a byte offset, the way an editor counts. */
+function lineColumn(text, offset) {
+    const before = text.slice(0, Math.max(0, offset));
+    const line = before.split("\n").length;
+    const column = offset - (before.lastIndexOf("\n") + 1) + 1;
+    return `${String(line)}:${String(column)}`;
+}
+/** The source line with a caret under the span, the way a compiler shows one. */
+function excerpt(text, start, end) {
+    const lineStart = text.lastIndexOf("\n", Math.max(0, start - 1)) + 1;
+    const lineEnd = text.indexOf("\n", start);
+    const line = text.slice(lineStart, lineEnd < 0 ? text.length : lineEnd);
+    const width = Math.max(1, Math.min(end, lineEnd < 0 ? text.length : lineEnd) - start);
+    return [
+        `  ${line}`,
+        `  ${" ".repeat(Math.max(0, start - lineStart))}${"^".repeat(width)}`,
+    ];
+}
+/**
+ * What `explain` says to a person.
+ *
+ * It used to print the raw origin records: interned numeric ids, byte offsets,
+ * and a `sourceId` in place of a file name. That is the shape a tool wants,
+ * and it is still available behind `--json`, but a command called `explain`
+ * should answer in the terms the question was asked in.
+ */
+function describeExplanation(options) {
+    const { explanation, fileName, sourceText, generatedText } = options;
+    const lines = [
+        `${fileName}:${lineColumn(sourceText, explanation.offset)}`,
+        ...excerpt(sourceText, explanation.offset, explanation.offset + 1),
+    ];
+    if (explanation.regions.length === 0) {
+        lines.push("", "This position produced no generated TypeScript.");
+        return `${lines.join("\n")}\n`;
+    }
+    const kinds = new Set(explanation.regions.map(({ kind }) => kind));
+    const stack = explanation.regions.flatMap(({ expansionStack }) => expansionStack);
+    lines.push("");
+    if (stack.length === 0) {
+        lines.push("Copied through expansion untouched.");
+    }
+    else {
+        const seen = new Set();
+        lines.push("Expanded by:");
+        for (const entry of stack) {
+            if (seen.has(entry.invocationId))
+                continue;
+            seen.add(entry.invocationId);
+            lines.push(`  ${entry.macroName}, invoked at ${fileName}:${lineColumn(sourceText, entry.origin.start)}`);
+        }
+    }
+    lines.push("", "Generated at:");
+    // Layout regions are where the whitespace around a token went. They answer a
+    // question nobody asked here, and there are more of them than of anything
+    // else, so the interesting regions do not get lost among them.
+    const regions = [...explanation.regions]
+        .filter(({ generatedStart, generatedEnd }) => generatedText.slice(generatedStart, generatedEnd).trim().length > 0)
+        .sort((left, right) => left.generatedStart - right.generatedStart);
+    for (const region of regions) {
+        const at = lineColumn(generatedText, region.generatedStart);
+        const text = generatedText
+            .slice(region.generatedStart, region.generatedEnd)
+            .replaceAll("\n", "\\n");
+        lines.push(`  ${at}  ${JSON.stringify(text)}${region.kind === "source" ? "" : ` (${region.kind})`}`);
+    }
+    if (kinds.has("introduced"))
+        lines.push("", "`introduced` marks syntax the macro wrote rather than syntax it was given.");
+    return `${lines.join("\n")}\n`;
+}
+export function runCli(options) {
+    const expansionProvider = options.expansionProvider ?? createDefaultProjectExpansionProvider();
+    const inspectionProvider = options.inspectionProvider ??
+        ("inspectSource" in expansionProvider
+            ? expansionProvider
+            : undefined);
+    let invocation;
+    try {
+        invocation = parseCliInvocation(options.argv);
+    }
+    catch (error) {
+        options.io.stderr(`${error instanceof Error ? error.message : String(error)}\n`);
+        return Object.freeze({ exitCode: 1 });
+    }
+    if (invocation.command === "help") {
+        options.io.stdout(usage);
+        return Object.freeze({ exitCode: 0 });
+    }
+    const report = (result) => {
+        for (const diagnostic of result.diagnostics)
+            options.io.stderr(`${renderDiagnostic(diagnostic)}\n`);
+        if ("debug" in invocation && invocation.debug)
+            options.io.stdout(`${JSON.stringify(result.debugState, null, 2)}\n`);
+        options.io.stdout(`${result.command}: ${result.exitCode === 0 ? "success" : "failed"}\n`);
+    };
+    if (invocation.command === "emit") {
+        const result = emitStandalone({
+            fileNames: invocation.fileNames,
+            outDir: invocation.outDir,
+            expansionProvider,
+        });
+        for (const diagnostic of result.diagnostics)
+            options.io.stderr(`${renderDiagnostic(diagnostic)}\n`);
+        if (result.diagnostics.length > 0) {
+            options.io.stdout("emit: failed\n");
+            return Object.freeze({ exitCode: 1 });
+        }
+        for (const fileName of result.outputs.keys())
+            options.io.stdout(`${fileName}\n`);
+        options.io.stdout("emit: success\n");
+        return Object.freeze({ exitCode: 0 });
+    }
+    if (invocation.command === "init") {
+        try {
+            // A project that already builds itself gets what it is missing, not a
+            // refusal: adding macros to something that exists is the ordinary case,
+            // and starting from nothing is the rare one.
+            const manifestPath = resolve(invocation.directory, "package.json");
+            const existing = existsSync(manifestPath)
+                ? JSON.parse(readFileSync(manifestPath, "utf8"))
+                : undefined;
+            // A project built for a runtime that needs no package.json is still a
+            // project, and writing one into it would be the wrong thing entirely.
+            const settled = existing !== undefined ||
+                ["deno.json", "deno.jsonc", "bunfig.toml", "tsconfig.json"].some((name) => existsSync(resolve(invocation.directory, name)));
+            const project = settled
+                ? scaffoldIntoProject({
+                    directory: invocation.directory,
+                    manifest: existing,
+                })
+                : scaffoldProject({ directory: invocation.directory });
+            // Said in full before anything happens, because this writes into a
+            // directory someone else owns.
+            options.io.stdout(`${[
+                `In ${resolve(invocation.directory)} this will create:`,
+                ...project.files.map(({ path }) => `  ${path}`),
+                "",
+                "It will not modify or delete anything already there.",
+                "",
+            ].join("\n")}`);
+            if (!invocation.assumeYes) {
+                if (options.io.confirm === undefined) {
+                    options.io.stderr("Nothing here can ask for confirmation. Re-run with --yes to write these files.\n");
+                    return Object.freeze({ exitCode: 1 });
+                }
+                if (!options.io.confirm("Create them? [y/N] ")) {
+                    options.io.stdout("Nothing was written.\n");
+                    return Object.freeze({ exitCode: 0 });
+                }
+            }
+            const written = writeScaffold(project, invocation.directory);
+            options.io.stdout(`${[
+                "Created:",
+                ...written.map((path) => `  ${path}`),
+                "",
+                // A note may carry a block to paste into a config file. Only its
+                // first line is a bullet; the rest is printed as it should appear.
+                ...project.notes.map((note) => note
+                    .split("\n")
+                    .map((line, index) => (index === 0 ? `- ${line}` : `  ${line}`))
+                    .join("\n")),
+                "",
+            ].join("\n")}`);
+            return Object.freeze({ exitCode: 0 });
+        }
+        catch (error) {
+            options.io.stderr(`${error instanceof Error ? error.message : String(error)}\n`);
+            return Object.freeze({ exitCode: 1 });
+        }
+    }
+    if (invocation.command === "expand" || invocation.command === "explain") {
+        if (inspectionProvider === undefined) {
+            options.io.stderr("Expansion inspection is unavailable\n");
+            return Object.freeze({ exitCode: 1 });
+        }
+        // Expanding the named project first is what makes `-p` mean anything: the
+        // inspection provider answers about files it has already expanded, and on
+        // its own it only ever discovers a tsconfig.json.
+        if (invocation.configPath !== undefined) {
+            if (!("expandProject" in inspectionProvider)) {
+                options.io.stderr("This expansion provider cannot load a project\n");
+                return Object.freeze({ exitCode: 1 });
+            }
+            try {
+                inspectionProvider.expandProject(loadSweetProject(resolve(invocation.configPath)));
+            }
+            catch (error) {
+                options.io.stderr(`${error instanceof Error ? error.message : String(error)}\n`);
+                return Object.freeze({ exitCode: 1 });
+            }
+        }
+        const position = invocation.command === "explain"
+            ? parseSourcePosition(invocation.position)
+            : undefined;
+        const fileName = invocation.command === "expand"
+            ? invocation.fileName
+            : position.fileName;
+        const inspected = inspectionProvider.inspectSource(fileName) ??
+            ("prepareSource" in inspectionProvider &&
+                typeof inspectionProvider.prepareSource === "function"
+                ? inspectionProvider.prepareSource(fileName)
+                : undefined);
+        if (inspected === undefined) {
+            options.io.stderr(`No expansion available for ${fileName}\n`);
+            return Object.freeze({ exitCode: 1 });
+        }
+        // Printing the source, or an account of where it came from, and reporting
+        // success would say the macros ran. `explain` used to report the origins of
+        // an expansion that never happened, which reads as an expansion in which
+        // every token came from the source -- exactly what an unexpanded file looks
+        // like.
+        if (inspected.diagnostics.length > 0) {
+            for (const diagnostic of inspected.diagnostics)
+                options.io.stderr(`${renderDiagnostic(diagnostic)}\n`);
+            return Object.freeze({ exitCode: 1 });
+        }
+        if (invocation.command === "expand") {
+            options.io.stdout(expansionView(inspected.generated));
+        }
+        else {
+            // A position past the end of the file is something a person types, not
+            // an internal fault: it used to escape as a raw stack trace naming dist
+            // paths.
+            let offset;
+            try {
+                offset = sourceOffset(inspected.sourceText, position.line, position.column);
+            }
+            catch {
+                const lines = inspected.sourceText.split("\n").length;
+                options.io.stderr(`${fileName} has ${String(lines)} line${lines === 1 ? "" : "s"}; ` +
+                    `${String(position.line)}:${String(position.column)} is outside it\n`);
+                return Object.freeze({ exitCode: 1 });
+            }
+            const explanation = explainOriginalPosition({
+                sourceId: inspected.sourceId,
+                offset,
+                index: inspected.index,
+                trace: inspected.trace,
+                generatedNames: inspected.generatedNames,
+            });
+            options.io.stdout(invocation.json === true
+                ? `${JSON.stringify(explanation, null, 2)}\n`
+                : describeExplanation({
+                    explanation,
+                    fileName,
+                    sourceText: inspected.sourceText,
+                    generatedText: inspected.generated.text,
+                }));
+        }
+        return Object.freeze({ exitCode: 0 });
+    }
+    if (invocation.command === "watch") {
+        // `build: success` on its own said nothing about when it happened or
+        // whether the run was still watching, so a rebuild was indistinguishable
+        // from the first build scrolling past.
+        const time = () => new Date().toLocaleTimeString(undefined, { hour12: false });
+        let first = true;
+        const watch = watchConfiguredProject({
+            configPath: invocation.configPath,
+            expansionProvider,
+            onResult: (result) => {
+                options.io.stdout(`[${time()}] ${first ? "Building" : "Rebuilding"} ${invocation.configPath}\n`);
+                first = false;
+                report(result);
+                options.io.stdout(`[${time()}] Watching for changes. Press Ctrl+C to stop.\n`);
+            },
+            ...(options.system === undefined ? {} : { system: options.system }),
+        });
+        return Object.freeze({ exitCode: watch.result.exitCode, watch });
+    }
+    const result = runConfiguredProjectCommand({
+        command: invocation.command,
+        configPath: invocation.configPath,
+        expansionProvider,
+    });
+    report(result);
+    return Object.freeze({ exitCode: result.exitCode });
+}
+//# sourceMappingURL=command-line.js.map