no-mistakes 0.48.0 → 0.48.2

package/README.md

@@ -70,7 +70,7 @@ const {
     changedFiles: ["src/utils.mts"],
   });
   // Complete changed-file inventory, including paths that selected no tests.
-  console.log(plan.changed_files);
+  console.log(plan.changedFiles);
   const targetCommands = await testsTargets({
     root: process.cwd(),
     framework: "vitest",

package/index.js

@@ -5,6 +5,8 @@
 const native = require(process.env.NO_MISTAKES_TEST_NAPI_ADDON_PATH || "./bin/no-mistakes.node");
 const planning = require("./planning");
 const { createWorkflowTopologyIndex } = require("./workflow-topology-index");
+const fs = require("node:fs");
+const path = require("node:path");
 
 async function callJson(fn, options) {
   const input = Buffer.from(JSON.stringify(options || {}));
@@ -59,19 +61,90 @@ const jsonApis = createJsonApis({
   symbols: "symbolsJson",
 });
 
+const PLAN_INPUT_REPORTS = new Set(["testsComment", "testsGraph", "testsGraphMermaid"]);
+const CAMELIZE_REPORTS = new Set(["testsPlan", "testsImpact", "testsTargets", "testsGraph"]);
+
+async function analyzeProject(options = {}) {
+  const request = { ...options };
+  const generatedDirs = [];
+  try {
+    if (Array.isArray(request.reports)) {
+      request.reports = await Promise.all(
+        request.reports.map(async (report) => {
+          if (report.type === "testsWhy") {
+            const prepared = await planning.prepareWhyPlan(report);
+            if (prepared.generatedDir) generatedDirs.push(prepared.generatedDir);
+            return prepared.request;
+          }
+          return PLAN_INPUT_REPORTS.has(report.type)
+            ? await planning.decamelizePlanOptions(report)
+            : report;
+        }),
+      );
+    }
+    const result = await jsonApis.analyzeProject(request);
+    for (const report of result.reports || []) {
+      if (report.type === "testsWhy") {
+        report.result = planning.camelizeWhy(report.result);
+      } else if (CAMELIZE_REPORTS.has(report.type)) {
+        report.result = planning.camelizeValue(report.result);
+      }
+    }
+    return result;
+  } finally {
+    await Promise.all(generatedDirs.map((dir) => planning.removeGeneratedDir(dir)));
+  }
+}
+
+const topologyMemo = new Map();
+
+async function ciTopology(options) {
+  const root = path.resolve((options && options.root) || process.cwd());
+  const configPath = path.resolve(root, (options && options.config) || ".no-mistakes.yml");
+  let mtime = 0;
+  try {
+    mtime = fs.statSync(configPath).mtimeMs;
+  } catch {
+    mtime = 0;
+  }
+  const workflows = JSON.stringify(
+    []
+      .concat((options && options.workflows) || [])
+      .map(String)
+      .sort(),
+  );
+  const identity = `${root}\0${configPath}\0`;
+  const key = `${identity}${mtime}\0${workflows}`;
+  const stale = [];
+  for (const memoKey of topologyMemo.keys()) {
+    if (!memoKey.startsWith(identity)) continue;
+    const memoMtime = memoKey.slice(identity.length).split("\0")[0];
+    if (memoMtime !== String(mtime)) stale.push(memoKey);
+  }
+  for (const memoKey of stale) topologyMemo.delete(memoKey);
+  const cached = topologyMemo.get(key);
+  if (cached) return cached.then((value) => structuredClone(value));
+  const pending = jsonApis.ciTopology({ ...options, root }).catch((error) => {
+    topologyMemo.delete(key);
+    throw error;
+  });
+  topologyMemo.set(key, pending);
+  return pending.then((value) => structuredClone(value));
+}
+
 async function version() {
   return native.version();
 }
 
 module.exports.createWorkflowTopologyIndex = createWorkflowTopologyIndex;
 module.exports.version = version;
-module.exports.analyzeProject = jsonApis.analyzeProject;
+module.exports.analyzeProject = analyzeProject;
 module.exports.callSites = jsonApis.callSites;
 module.exports.check = jsonApis.check;
 module.exports.resolveConfig = jsonApis.resolveConfig;
 module.exports.ciEnv = jsonApis.ciEnv;
 module.exports.ciImpact = jsonApis.ciImpact;
-module.exports.ciTopology = jsonApis.ciTopology;
+module.exports.ciTopology = ciTopology;
 module.exports.dataPw = jsonApis.dataPw;
 module.exports.deadExports = jsonApis.deadExports;
 module.exports.dependencies = jsonApis.dependencies;

package/invocation-types.d.ts

@@ -11,6 +11,8 @@ export interface InvocationOptions {
    * `0` uses the CPU count, matching CLI `--jobs 0`.
    */
   jobs?: number | null;
+  /** `ci` sets unbounded command and lock timeouts. CLI `--profile ci` does the same. */
+  profile?: "ci";
 }
 
 export type WithInvocationOptions<T> = T & InvocationOptions;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "no-mistakes",
-  "version": "0.48.0",
+  "version": "0.48.2",
   "description": "Static codebase analysis tools for TS/JS dependencies, dependents, and symbols",
   "license": "MIT",
   "repository": {
@@ -18,6 +18,7 @@
     "index.mjs",
     "planning.js",
     "workflow-topology-index.js",
+    "workflow-topology-index-helpers.js",
     "scripts/install.js",
     "scripts/install/",
     "README.md",

package/planning.js

@@ -1,5 +1,8 @@
 "use strict";
 
+const fs = require("node:fs/promises");
+const os = require("node:os");
+const path = require("node:path");
 const native = require(process.env.NO_MISTAKES_TEST_NAPI_ADDON_PATH || "./bin/no-mistakes.node");
 
 async function callJson(fn, options) {
@@ -16,13 +19,109 @@ function createJsonApis(descriptors) {
   );
 }
 
+function camelizeKey(key) {
+  return key.replace(/_([a-z])/g, (_, letter) => letter.toUpperCase());
+}
+
+function decamelizeKey(key) {
+  return key.replace(/[A-Z]/g, (letter) => `_${letter.toLowerCase()}`);
+}
+
+function mapKeys(value, mapKey) {
+  if (Array.isArray(value)) return value.map((item) => mapKeys(item, mapKey));
+  if (value && typeof value === "object") {
+    return Object.fromEntries(
+      Object.entries(value).map(([key, nested]) => [mapKey(key), mapKeys(nested, mapKey)]),
+    );
+  }
+  return value;
+}
+
+function camelizeValue(value) {
+  return mapKeys(value, camelizeKey);
+}
+
+function decamelizeValue(value) {
+  return mapKeys(value, decamelizeKey);
+}
+
+function loadPlanJson(planJson) {
+  let parsed = planJson;
+  if (typeof parsed === "string") {
+    try {
+      parsed = JSON.parse(parsed);
+    } catch {
+      return planJson;
+    }
+  }
+  if (parsed && typeof parsed === "object") {
+    return decamelizeValue(parsed);
+  }
+  return planJson;
+}
+
+async function readPlanFile(planPath) {
+  try {
+    return JSON.parse(await fs.readFile(planPath, "utf8"));
+  } catch {
+    return undefined;
+  }
+}
+
+async function decamelizePlanOptions(options = {}) {
+  const next = { ...options };
+  if (next.planJson != null) {
+    next.planJson = loadPlanJson(next.planJson);
+  } else if (typeof next.plan === "string") {
+    const document = await readPlanFile(next.plan);
+    if (document !== undefined) {
+      next.planJson = loadPlanJson(document);
+      delete next.plan;
+    }
+  }
+  return next;
+}
+
+async function prepareWhyPlan(options = {}) {
+  const next = { ...options };
+  let document = next.planJson;
+  if (document == null && typeof next.plan === "string") {
+    document = await readPlanFile(next.plan);
+    if (document === undefined) return { request: next };
+  }
+  if (document == null) return { request: next };
+  const generatedDir = await fs.mkdtemp(path.join(os.tmpdir(), "no-mistakes-why-"));
+  await fs.writeFile(path.join(generatedDir, "plan.json"), JSON.stringify(loadPlanJson(document)));
+  next.plan = path.join(generatedDir, "plan.json");
+  delete next.planJson;
+  return { request: next, generatedDir };
+}
+
+async function materializeWhyPlan(options = {}) {
+  return (await prepareWhyPlan(options)).request;
+}
+
+async function removeGeneratedDir(generatedDir) {
+  if (!generatedDir) return;
+  await fs.rm(generatedDir, { recursive: true, force: true }).catch(() => {});
+}
+
+function camelizeWhy(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    return camelizeValue(value);
+  }
+  return Object.fromEntries(
+    Object.entries(value).map(([key, nested]) => [key, camelizeValue(nested)]),
+  );
+}
+
 async function testsComment(options) {
-  const input = Buffer.from(JSON.stringify(options || {}));
+  const input = Buffer.from(JSON.stringify(await decamelizePlanOptions(options)));
   return String(await native.testsCommentMarkdown(input));
 }
 
 async function testsGraphMermaid(options) {
-  const input = Buffer.from(JSON.stringify(options || {}));
+  const input = Buffer.from(JSON.stringify(await decamelizePlanOptions(options)));
   return String(await native.testsGraphMermaid(input));
 }
 
@@ -44,8 +143,44 @@ const jsonApis = createJsonApis({
   testsWhy: "testsWhyJson",
 });
 
+async function testsPlan(options) {
+  return camelizeValue(await jsonApis.testsPlan(options));
+}
+
+async function testsImpact(options) {
+  return camelizeValue(await jsonApis.testsImpact(options));
+}
+
+async function testsTargets(options) {
+  return camelizeValue(await jsonApis.testsTargets(options));
+}
+
+async function testsWhy(options) {
+  const { request, generatedDir } = await prepareWhyPlan(options);
+  try {
+    return camelizeWhy(await jsonApis.testsWhy(request));
+  } finally {
+    await removeGeneratedDir(generatedDir);
+  }
+}
+
+async function testsGraph(options) {
+  return camelizeValue(await jsonApis.testsGraph(await decamelizePlanOptions(options)));
+}
+
 module.exports = {
+  camelizeValue,
+  camelizeWhy,
+  decamelizePlanOptions,
+  materializeWhyPlan,
+  prepareWhyPlan,
+  removeGeneratedDir,
   testsComment,
   testsGraphMermaid,
   ...jsonApis,
+  testsGraph,
+  testsImpact,
+  testsPlan,
+  testsTargets,
+  testsWhy,
 };

package/test-types.d.ts

@@ -13,6 +13,8 @@ export type TestPlanFramework =
   | "php"
   | "java"
   | "kotlin"
+  | "elixir"
+  | "dart"
   | "jest";
 
 interface TestsPlanOptionsBase {
@@ -41,6 +43,8 @@ interface TestsPlanOptionsBase {
   globalConfigFallback?: boolean;
   /** Include the markdown PR comment as `comment` on the returned plan. */
   includeComment?: boolean;
+  /** Keep only selected tests whose relative path matches one of these globs. */
+  includeGlob?: string[];
 }
 
 /**
@@ -90,18 +94,12 @@ export interface TestsTargetsOptions {
 
 export interface TestPlan {
   /** Complete deterministic changed-file inventory, relative to the request root. */
-  changed_files: string[];
-  /** @deprecated Prefer `changedFiles` once both keys are present. */
-  changedFiles?: string[];
-  selected_tests: SelectedTest[];
-  selectedTests?: SelectedTest[];
+  changedFiles: string[];
+  selectedTests: SelectedTest[];
   groups?: TestPlanGroup[];
   warnings: TestPlanWarning[];
-  fallback_triggered: boolean;
-  fallbackTriggered?: boolean;
-  fallback_reason?: string | null;
+  fallbackTriggered: boolean;
   fallbackReason?: string | null;
-  execution_targets?: GroupedExecutionTarget[];
   executionTargets?: GroupedExecutionTarget[];
   comment?: string | null;
 }
@@ -110,16 +108,15 @@ export interface GroupedExecutionTarget {
   runner: TestPlanFramework;
   config?: string | null;
   project?: string | null;
-  baseCommand?: string[];
-  base_command: string[];
-  runnerArgs?: string[];
-  runner_args: string[];
-  testFiles?: string[];
-  test_files: string[];
+  /** Path-prefix display name, such as a Swift package root. */
+  name?: string;
+  baseCommand: string[];
+  runnerArgs: string[];
+  testFiles: string[];
 }
 
 export interface SelectedTest {
-  test_file: string;
+  testFile: string;
   confidence: "low" | "medium" | "high";
   reasons: ImpactReason[];
   targets?: TestExecutionTarget[];
@@ -131,24 +128,26 @@ export interface TestExecutionTarget {
   /** True when config is a Vitest workspace/project-array source rendered with --workspace. */
   workspace?: boolean;
   project?: string | null;
-  base_command: string[];
-  runner_args: string[];
+  /** Path-prefix display name, such as a Swift package root. */
+  name?: string;
+  baseCommand: string[];
+  runnerArgs: string[];
 }
 
 export interface ImpactReason {
-  changed_file: string;
+  changedFile: string;
   path: string[];
   via: string[];
   /** When present, aligns index-for-index with `via`. */
-  via_details?: Array<ImpactEdgeDetail | null>;
+  viaDetails?: Array<ImpactEdgeDetail | null>;
 }
 
 export type ImpactEdgeDetail = ResourceImpactEdgeDetail | VitestSetupImpactEdgeDetail;
 
 export interface ResourceImpactEdgeDetail {
   type: "resource";
-  consumer_file: string;
-  call_sites: ResourceCallSite[];
+  consumerFile: string;
+  callSites: ResourceCallSite[];
 }
 
 export interface VitestSetupImpactEdgeDetail {
@@ -157,7 +156,7 @@ export interface VitestSetupImpactEdgeDetail {
 }
 
 export interface ResourceCallSite {
-  call_kind: ResourceCallKind;
+  callKind: ResourceCallKind;
   line: number;
 }
 
@@ -211,6 +210,7 @@ export interface TestsWhyOptions {
   test: string;
   changed?: string;
   plan?: string;
+  planJson?: SavedTestPlan | string;
 }
 
 export interface WhyStep {
@@ -219,10 +219,8 @@ export interface WhyStep {
   detail?: ImpactEdgeDetail | null;
 }
 
-/** A current or pre-`changed_files` plan accepted by saved-plan document APIs. */
-export type SavedTestPlan = Omit<TestPlan, "changed_files"> & {
-  changed_files?: string[];
-};
+/** A current or pre-`changedFiles` plan accepted by saved-plan document APIs. */
+export type SavedTestPlan = TestPlan;
 
 export interface TestsPlanDocumentOptions {
   plan?: string;

package/traversal-types.d.ts

@@ -33,6 +33,8 @@ export type Relationship =
   | "php"
   | "java"
   | "kotlin"
+  | "elixir"
+  | "dart"
   | "resource"
   | "trpc"
   | "all";

package/workflow-topology-index-helpers.js

@@ -0,0 +1,28 @@
+"use strict";
+
+function stepMatches(selector, step) {
+  return (
+    (selector.id === undefined || selector.id === step.id) &&
+    (selector.uses === undefined || selector.uses === step.uses) &&
+    (selector.name === undefined || selector.name === step.name)
+  );
+}
+
+function directCallerJobIdsForUses(jobsById, uses) {
+  const ids = [];
+  for (const job of jobsById.values()) {
+    if (job.steps.some((step) => step.uses === uses)) ids.push(job.id);
+  }
+  return Object.freeze(ids.sort());
+}
+
+function stepOrderIndexes(job, selectors) {
+  return Object.freeze(
+    selectors.map((selector) => {
+      const step = job.steps.find((candidate) => stepMatches(selector, candidate));
+      return step == null ? -1 : step.index;
+    }),
+  );
+}
+
+module.exports = { directCallerJobIdsForUses, stepOrderIndexes };

package/workflow-topology-index-types.d.ts

@@ -24,6 +24,13 @@ export interface WorkflowTopologyIndex {
   directDownstreamJobIds(jobId: string): readonly string[];
   transitiveDownstreamJobIds(jobId: string): readonly string[];
   directCallerJobIds(workflowPath: string): readonly string[];
+  /** Job ids whose steps `uses:` this action or workflow path. */
+  directCallerJobIdsForUses(uses: string): readonly string[];
+  /** Step indexes for `selectors` in `jobId`, or `-1` when a selector is missing. */
+  stepOrderIndexes(
+    jobId: string,
+    selectors: ReadonlyArray<{ id?: string; uses?: string; name?: string }>,
+  ): readonly number[];
   directCallerWorkflowPaths(workflowPath: string): readonly string[];
   transitiveCallerWorkflowPaths(workflowPath: string): readonly string[];
   directCalleeWorkflowPaths(workflowPath: string): readonly string[];

package/workflow-topology-index.js

@@ -1,5 +1,10 @@
 "use strict";
 
+const {
+  directCallerJobIdsForUses,
+  stepOrderIndexes,
+} = require("./workflow-topology-index-helpers");
+
 // A pure-JS query index rebuilt from the `ciTopology()` JSON, ported from
 // the original engine's `topology-index.mts` + `frozen-topology.mts`. This
 // stays JS-only by design: it returns closures over frozen `Map`s, which
@@ -214,6 +219,11 @@ function createWorkflowTopologyIndex(topology) {
     transitiveWorkflowRunSubscriberPaths: workflowQuery(workflowRunSubscribers, true),
     artifactProducersForConsumerJob: artifactEdgeQuery(artifactProducers),
     artifactConsumersForProducerJob: artifactEdgeQuery(artifactConsumers),
+    directCallerJobIdsForUses: (uses) => directCallerJobIdsForUses(jobsById, uses),
+    stepOrderIndexes: (jobId, selectors) => {
+      assertKnown(jobsById, jobId, "workflow job");
+      return stepOrderIndexes(jobsById.get(jobId), selectors);
+    },
   });
 }