no-mistakes 0.52.2 → 0.53.1

package/README.md

@@ -15,8 +15,13 @@ npx no-mistakes dependents src/utils.mts --json
 npx no-mistakes symbols src/utils.mts --json
 npx no-mistakes import-usages --root . --filter 'src/**' --json
 npx no-mistakes check --json
+npx no-mistakes planning-impact --changed-files /private/run/changed-files.txt --output-dir /private/run
 ```
 
+`planning-impact` is supplied by the npm package, not the Cargo-installed
+binary. It writes the private four-report artifact contract from one prepared
+analysis. See the [CLI reference](../../docs/cli/planning-impact.md).
+
 Programmatic Node usage loads the same Rust analysis through N-API:
 
 ```js

package/bin/no-mistakes.js

@@ -0,0 +1,74 @@
+#!/usr/bin/env node
+"use strict";
+
+const { spawn } = require("node:child_process");
+const { join } = require("node:path");
+const { boundedDiagnostic } = require("../planning-impact-cli");
+
+const VALUE_OPTIONS = new Set(["--timeout", "--lock-timeout", "--jobs", "--profile", "-j"]);
+const FLAG_OPTIONS = new Set(["--fail-on-lock"]);
+const INLINE_VALUE_OPTION = /^(?:--(?:timeout|lock-timeout|jobs|profile)=|-j)/u;
+
+function firstSubcommand(argv) {
+  const index = firstSubcommandIndex(argv);
+  return index === undefined ? undefined : argv[index];
+}
+
+function firstSubcommandIndex(argv) {
+  for (let index = 0; index < argv.length; index += 1) {
+    const value = argv[index];
+    if (value === "--") return undefined;
+    if (VALUE_OPTIONS.has(value)) {
+      index += 1;
+      continue;
+    }
+    if (FLAG_OPTIONS.has(value) || INLINE_VALUE_OPTION.test(value)) {
+      continue;
+    }
+    return index;
+  }
+  return undefined;
+}
+
+function planningImpactArgs(argv) {
+  const index = firstSubcommandIndex(argv);
+  return [...argv.slice(0, index), ...argv.slice(index + 1)];
+}
+
+function launchNative(argv, spawnFn = spawn, io = process, kill = process.kill) {
+  const child = spawnFn(join(__dirname, "no-mistakes"), argv, { stdio: "inherit" });
+  child.on("error", (error) => {
+    io.stderr.write(`${error instanceof Error ? error.message : String(error)}\n`);
+    io.exitCode = 1;
+  });
+  child.on("exit", (code, signal) => {
+    if (signal) kill(process.pid, signal);
+    else io.exitCode = code === null ? 1 : code;
+  });
+  return child;
+}
+
+async function main(
+  argv = process.argv.slice(2),
+  {
+    io = process,
+    launchNativeFn = launchNative,
+    runPlanning = (args, planningIo) =>
+      require("../planning-impact-cli").main(args, process.cwd(), planningIo),
+  } = {},
+) {
+  if (firstSubcommand(argv) === "planning-impact") {
+    try {
+      await runPlanning(planningImpactArgs(argv), io);
+    } catch (error) {
+      io.stderr.write(boundedDiagnostic(error));
+      io.exitCode = 1;
+    }
+  } else {
+    launchNativeFn(argv);
+  }
+}
+
+if (require.main === module) void main();
+
+module.exports = { firstSubcommand, launchNative, main, planningImpactArgs };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "no-mistakes",
-  "version": "0.52.2",
+  "version": "0.53.1",
   "description": "Static codebase analysis tools for TS/JS dependencies, dependents, and symbols",
   "license": "MIT",
   "repository": {
@@ -9,7 +9,7 @@
     "directory": "packages/no-mistakes"
   },
   "bin": {
-    "no-mistakes": "bin/no-mistakes"
+    "no-mistakes": "bin/no-mistakes.js"
   },
   "files": [
     "bin/",
@@ -22,6 +22,7 @@
     "planning-impact-artifacts-inputs.js",
     "planning-impact-artifacts-lock.js",
     "planning-impact-artifacts-privacy.js",
+    "planning-impact-cli.js",
     "planning.js",
     "workflow-topology-index.js",
     "workflow-topology-index-helpers.js",

package/planning-impact-cli.js

@@ -0,0 +1,81 @@
+"use strict";
+
+const { parseArgs } = require("node:util");
+
+const USAGE = [
+  "usage: no-mistakes planning-impact --changed-files <manifest>",
+  "--output-dir <directory> [--broad]",
+].join(" ");
+
+function parseNonNegativeInteger(name, value) {
+  if (!/^(?:0|[1-9][0-9]*)$/u.test(value)) {
+    throw new Error(`${name} must be a non-negative integer`);
+  }
+  const parsed = Number(value);
+  if (!Number.isSafeInteger(parsed)) throw new Error(`${name} must be a safe integer`);
+  return parsed;
+}
+
+function parsePlanningImpactArgs(argv, root) {
+  const { values } = parseArgs({
+    args: argv,
+    options: {
+      "changed-files": { type: "string" },
+      "output-dir": { type: "string" },
+      broad: { type: "boolean" },
+      timeout: { type: "string" },
+      "lock-timeout": { type: "string" },
+      "fail-on-lock": { type: "boolean" },
+      jobs: { type: "string", short: "j" },
+      profile: { type: "string" },
+      help: { type: "boolean", short: "h" },
+    },
+    strict: true,
+  });
+  if (values.help) return null;
+  if (!values["changed-files"] || !values["output-dir"]) throw new Error(USAGE);
+  if (values.profile !== undefined && values.profile !== "ci") {
+    throw new Error('profile must be "ci" when set');
+  }
+  const options = {
+    root,
+    changedFilesManifest: values["changed-files"],
+    outputDirectory: values["output-dir"],
+    broad: values.broad === true,
+  };
+  for (const [flag, key] of [
+    ["timeout", "timeout"],
+    ["lock-timeout", "lockTimeout"],
+    ["jobs", "jobs"],
+  ]) {
+    if (values[flag] !== undefined) options[key] = parseNonNegativeInteger(flag, values[flag]);
+  }
+  if (values["fail-on-lock"]) options.failOnLock = true;
+  if (values.profile) options.profile = values.profile;
+  return options;
+}
+
+async function runPlanningImpact(argv, root, writer) {
+  const options = parsePlanningImpactArgs(argv, root);
+  if (options) await writer(options);
+  return options;
+}
+
+function boundedDiagnostic(error) {
+  const detail = error instanceof Error ? `${error.name}: ${error.message}` : String(error);
+  return Buffer.from(`${detail}\n`)
+    .subarray(0, 4096)
+    .toString("utf8")
+    .replace(/\ufffd+$/u, "");
+}
+
+async function main(argv = process.argv.slice(2), root = process.cwd(), io = process, writer) {
+  const options = parsePlanningImpactArgs(argv, root);
+  if (!options) {
+    io.stdout.write(`${USAGE}\n`);
+    return;
+  }
+  await (writer || require("./index").writePlanningImpactArtifacts)(options);
+}
+
+module.exports = { USAGE, boundedDiagnostic, main, parsePlanningImpactArgs, runPlanningImpact };

package/resolve-config-types.d.ts

@@ -41,6 +41,8 @@ export interface ResolvedTrigger {
   name: string;
   paths: string[];
   targets: string[];
+  /** Effective changed-test expansion policy; present only for structured triggers. */
+  includeChangedTests?: boolean;
   source: "triggers" | "projects";
 }