@cplieger/deadset-ts 8.0.0-dev.1 → 8.0.0-dev.11

package/dist/src/run.js

@@ -1,8 +1,12 @@
-import { ConfigError, REPOSITORY_DOCUMENT } from "./config.js";
-import { DiscoveryError, renderDiagnostic } from "./discover.js";
+import { CONFIG_MAX_BYTES, SETTINGS } from "./contract/config.generated.js";
+import { EXIT_FAILURE, EXIT_USAGE } from "./contract/contract.generated.js";
+import { REPOSITORY_DOCUMENT } from "./config.js";
+import { readTargetDocument } from "./fs/document.js";
 import { joinPath, resolvePath } from "./paths.js";
-import { readScope, ScopeError, scopeForDir } from "./scope.js";
-import { SetupError, setupLine } from "./setup-failure.js";
+import { renderDiagnostic } from "./load/diagnostics.js";
+import { FailureExit, failureLines, productFault } from "./failure.js";
+import { readScope, scopeForDir } from "./scope.js";
+import { UsageError } from "./usage.js";
 import { openEngine } from "./session.js";
 import { printConfigVerb } from "./verbs/print-config.js";
 import { printProjectsVerb } from "./verbs/print-projects.js";
@@ -11,8 +15,9 @@ import { printRootsVerb } from "./verbs/print-roots.js";
 import { ANALYZE_OPTIONS, analyzeVerb } from "./verbs/analyze.js";
 import { describeVerb } from "./verbs/describe.js";
 import { EXPLAIN_OPTIONS, explainVerb } from "./verbs/explain.js";
-import { EXIT_FAILURE, EXIT_USAGE } from "./verbs/verb.js";
+import {} from "./verbs/verb.js";
 import { versionVerb } from "./verbs/version.js";
+import { diagnose, message, PRODUCT } from "./product.js";
 /** Every verb this command answers, in the order the usage text lists them. */
 const VERBS = [
     { name: "analyze", run: analyzeVerb, options: ANALYZE_OPTIONS },
@@ -24,7 +29,7 @@ const VERBS = [
     { name: "describe", run: describeVerb },
     { name: "version", run: versionVerb },
 ];
-const USAGE = `usage: deadset-ts <verb> [options]\nverbs: ${VERBS.map((verb) => verb.name).join(", ")}\n`;
+const USAGE = `usage: ${PRODUCT} <verb> [options]\nverbs: ${VERBS.map((verb) => verb.name).join(", ")}\n`;
 /**
  * The tokens whose presence in an option's name makes that option a request to
  * edit a source file. The set is closed, and a token is matched in any position of
@@ -32,29 +37,12 @@ const USAGE = `usage: deadset-ts <verb> [options]\nverbs: ${VERBS.map((verb) =>
  */
 const SOURCE_EDIT_TOKENS = ["fix", "edit", "delete", "rewrite"];
 /**
- * Maps an option name to the setting of the Contract's configuration schema it supplies,
- * so one entry registers the option, supplies the document resolution reads, and gives
- * the spelling the setting's provenance names. The name is this command's vocabulary and
- * is never derived from the path: a setting reaches the command line only by an entry,
- * and a path names a key the schema declares.
+ * Maps an option name to the setting of the Contract's configuration schema it supplies:
+ * the options contract/settings.json names for a setting this analyzer reads.
  */
-export const SETTING_OPTIONS = new Map([
-    ["min-confidence", "analysis.min_confidence"],
-    ["sort", "reporters.sort"],
-    ["cascade", "reporters.cascade"],
-    ["max-findings", "reporters.max_findings"],
-    ["fail-on", "reporters.fail_on"],
-]);
+export const SETTING_OPTIONS = new Map(SETTINGS.flatMap((row) => (row.option === undefined ? [] : [[row.option, row.key]])));
 /** The options that take a value and are not settings. */
 const PLAIN_OPTIONS = new Set(["target", "config", "central", "scope"]);
-/**
- * The setting options whose value is an integer rather than a string. A value
- * written other than as digits is passed on as the string it is, so resolution
- * refuses it by its type rather than reading `1e2` as 100.
- */
-const INTEGER_OPTIONS = new Set(["max-findings"]);
-/** An integer as an option writes it: an optional minus sign and digits alone. */
-const INTEGER_TEXT = /^-?[0-9]+$/u;
 /** No option beyond the ones every verb takes. */
 const NO_OPTIONS = { plain: [], repeatable: [] };
 /**
@@ -81,7 +69,7 @@ function readOptions(args, own) {
     const repeated = new Map();
     for (const arg of args) {
         if (!arg.startsWith("-")) {
-            throw new ConfigError("malformed", "", `unexpected argument ${JSON.stringify(arg)}`);
+            throw new UsageError(`unexpected argument ${JSON.stringify(arg)}`);
         }
         const [spelled, ...rest] = arg.split("=");
         const name = (spelled ?? "").replace(/^-+/u, "");
@@ -89,10 +77,10 @@ function readOptions(args, own) {
             !SETTING_OPTIONS.has(name) &&
             !own.plain.includes(name) &&
             !own.repeatable.includes(name)) {
-            throw new ConfigError("malformed", "", `unknown option ${JSON.stringify(spelled ?? arg)}`);
+            throw new UsageError(`unknown option ${JSON.stringify(spelled ?? arg)}`);
         }
         if (rest.length === 0) {
-            throw new ConfigError("malformed", "", `option ${JSON.stringify(spelled ?? arg)} takes a value`);
+            throw new UsageError(`option ${JSON.stringify(spelled ?? arg)} takes a value`);
         }
         const value = rest.join("=");
         named.set(name, value);
@@ -100,45 +88,49 @@ function readOptions(args, own) {
     }
     return { named, repeated };
 }
-function readFileOr(host, path, orUndefined) {
+/** The document an option names. */
+function documentAt(host, label) {
     try {
-        return host.readFile(resolvePath(host.workingDirectory(), path));
+        const path = resolvePath(host.workingDirectory(), label);
+        // A file past the bound reads as one byte more than it, which resolution refuses.
+        return { text: host.readFile(path, CONFIG_MAX_BYTES + 1), label };
     }
     catch (error) {
-        if (orUndefined) {
-            return undefined;
-        }
-        throw new ConfigError("malformed", "", `${path}: ${error instanceof Error ? error.message : String(error)}`);
+        throw new UsageError(`${label}: ${message(error)}`);
     }
 }
 /**
- * The configuration documents one invocation reads: the repository configuration
- * at the target root or the path an option named, the central configuration, and
- * the settings the options supply as one flag document.
+ * The repository configuration at the target root, none where it is absent. One that
+ * cannot be read is a configuration document that cannot be, refused with the usage code.
+ */
+function repositoryAt(host, target) {
+    const label = joinPath(target, REPOSITORY_DOCUMENT);
+    const root = resolvePath(host.workingDirectory(), target);
+    const text = readTargetDocument(host, root, REPOSITORY_DOCUMENT, label, (named, reason) => new UsageError(`${named}: ${reason}`));
+    return text === undefined ? undefined : { text, label };
+}
+/**
+ * The configuration sources one invocation carries: the repository configuration at
+ * the target root or the path an option named, the central configuration, and the
+ * text each setting option was given.
  */
 function inputsOf(host, options) {
-    const target = options.named.get("target") ?? ".";
     const named = options.named.get("config");
-    const repositoryLabel = named ?? joinPath(target, REPOSITORY_DOCUMENT);
-    const repository = readFileOr(host, repositoryLabel, named === undefined);
+    const target = options.named.get("target") ?? ".";
+    const repository = named === undefined ? repositoryAt(host, target) : documentAt(host, named);
     const centralLabel = options.named.get("central");
-    const central = centralLabel === undefined ? undefined : readFileOr(host, centralLabel, false);
-    const flat = {};
-    const flagLabels = new Map();
-    for (const [name, path] of SETTING_OPTIONS) {
+    const central = centralLabel === undefined ? undefined : documentAt(host, centralLabel);
+    const flags = new Map();
+    for (const [name, key] of SETTING_OPTIONS) {
         const value = options.named.get(name);
-        if (value === undefined) {
-            continue;
+        if (value !== undefined) {
+            flags.set(key, value);
         }
-        flat[path] = INTEGER_OPTIONS.has(name) && INTEGER_TEXT.test(value) ? Number(value) : value;
-        flagLabels.set(path, `--${name}`);
     }
-    const flags = Object.keys(flat).length === 0 ? undefined : JSON.stringify(flat);
     return {
-        ...(flags === undefined ? {} : { flags }),
-        ...(repository === undefined ? {} : { repository, repositoryLabel }),
-        ...(central === undefined || centralLabel === undefined ? {} : { central, centralLabel }),
-        flagLabels,
+        flags,
+        ...(repository === undefined ? {} : { repository }),
+        ...(central === undefined ? {} : { central }),
     };
 }
 /** The scope one invocation analyzes: the document an option named, or the target. */
@@ -154,14 +146,12 @@ function scopeOf(host, options) {
  * the exit code: 0 for a completed verb, 1 for a finding that fails the run, 2 for a
  * usage error, a requested source edit or a refused configuration, 3 for a failure that
  * produced no answer. It writes nothing outside `out` and `err` and never exits the
- * process. `host` is the platform the run reads, the version it reports included, and
- * `openClient` opens the compiler client; a caller that watches what a run reads
- * supplies its own of either.
+ * process. A caller that watches what a run reads supplies its own `host` or `openClient`.
  */
 export function run(args, out, err, host, openClient = openEngine) {
     const editing = sourceEditOption(args);
     if (editing !== undefined) {
-        err.write(`deadset-ts: ${editing} is not supported: deadset-ts reports and never edits a source file\n`);
+        diagnose(err, `${editing} is not supported: ${PRODUCT} reports and never edits a source file`);
         err.write(USAGE);
         return EXIT_USAGE;
     }
@@ -171,7 +161,7 @@ export function run(args, out, err, host, openClient = openEngine) {
         return invoke(verb.run, verb.options ?? NO_OPTIONS, args.slice(1), { out, err, host }, openClient);
     }
     if (name !== undefined) {
-        err.write(`deadset-ts: unknown verb ${JSON.stringify(name)}\n`);
+        diagnose(err, `unknown verb ${JSON.stringify(name)}`);
     }
     err.write(USAGE);
     return EXIT_USAGE;
@@ -196,7 +186,7 @@ function invoke(verb, own, args, streams, openClient) {
             openClient: (config) => {
                 opened = openClient({
                     collectTiming: false,
-                    components: { extensions: config.ts.componentExtensions, host: streams.host },
+                    components: { extensions: config.ts.component_extensions, host: streams.host },
                 });
                 return opened;
             },
@@ -207,29 +197,28 @@ function invoke(verb, own, args, streams, openClient) {
         return refuse(error, streams.err);
     }
 }
-/** Turns one refusal into the exit code the Contract's table gives it. */
+/**
+ * Turns one refusal into the exit code the Contract's table gives it. An error no class names
+ * is a fault of this analyzer, printed with its stack for the maintainers it asks the user to
+ * report it to.
+ */
 function refuse(error, err) {
-    if (error instanceof ConfigError) {
-        err.write(`deadset-ts: ${error.message}\n`);
+    if (error instanceof UsageError) {
+        diagnose(err, error.message);
         err.write(USAGE);
         return EXIT_USAGE;
     }
-    if (error instanceof DiscoveryError) {
-        for (const diagnostic of error.diagnostics) {
-            err.write(`${renderDiagnostic(diagnostic)}\n`);
+    if (!(error instanceof FailureExit)) {
+        if (error instanceof Error && error.stack !== undefined) {
+            err.write(`${error.stack}\n`);
         }
-        err.write(`deadset-ts: ${error.message}\n`);
-        return EXIT_FAILURE;
+        return refuse(productFault(`meets an error none of its classes names: ${message(error)}`), err);
     }
-    if (error instanceof SetupError) {
-        for (const failure of error.failures) {
-            err.write(`${setupLine(failure)}\n`);
-        }
-        return EXIT_FAILURE;
+    for (const diagnostic of error.diagnostics) {
+        err.write(`${renderDiagnostic(diagnostic)}\n`);
     }
-    if (error instanceof ScopeError) {
-        err.write(`deadset-ts: ${error.message}\n`);
-        return EXIT_FAILURE;
+    for (const line of failureLines(error.failures)) {
+        err.write(`${line}\n`);
     }
-    throw error;
+    return EXIT_FAILURE;
 }