no-mistakes 0.8.0 → 0.9.1

package/README.md

@@ -11,6 +11,73 @@ npx no-mistakes symbols src/utils.mts --json
 npx no-mistakes check --json
 ```
 
+Programmatic Node usage loads the same Rust analysis through N-API:
+
+```js
+const {
+  dependencies,
+  dependents,
+  check,
+  fetches,
+  playwrightRelated,
+  symbols,
+  testsPlan,
+  queueEdges,
+  queueRelated,
+  queueCheck,
+  serverRouteList,
+  serverRouteEdges,
+  serverRouteRelated,
+  reactAnalyze,
+  reactCheck,
+} = require("no-mistakes");
+
+(async () => {
+  const deps = await dependencies({
+    root: process.cwd(),
+    files: ["src/main.mts"],
+    relationships: ["import"],
+  });
+  const tests = await dependents({
+    root: process.cwd(),
+    files: ["src/utils.mts"],
+    tests: ["vitest"],
+  });
+  const symbolFacts = await symbols({
+    root: process.cwd(),
+    files: ["src/utils.mts"],
+    include: "both",
+  });
+  const plan = await testsPlan({
+    root: process.cwd(),
+    framework: "vitest",
+    changedFiles: ["src/utils.mts"],
+  });
+  const projectCheck = await check({
+    root: process.cwd(),
+    tsconfig: "tsconfig.json",
+  });
+  const coveredByPlaywright = await playwrightRelated({
+    root: process.cwd(),
+    files: ["web/app/users/page.tsx"],
+  });
+
+  const queueHops = await queueRelated({
+    root: process.cwd(),
+    files: ["src/jobs/enqueue.ts"],
+    direction: "both",
+  });
+  const routeEdges = await serverRouteEdges({
+    root: process.cwd(),
+    roots: ["src/server.ts"],
+  });
+  const components = await reactAnalyze({
+    root: process.cwd(),
+    targets: ["app/**/*.tsx"],
+  });
+})();
+```
+
 External `no-mistakes-*` executables on `PATH` can be invoked as subcommands.
 For example, after installing `no-mistakes-scripts`:
 

package/bin/no-mistakes.node

@@ -0,0 +1 @@
+Native binary placeholder. Replaced by scripts/install.js during npm postinstall.

package/index.d.ts

@@ -0,0 +1,51 @@
+import type {
+  CheckReport,
+  DependencyResult,
+  FetchesOptions,
+  GraphEdge,
+  PlaywrightOptions,
+  PlaywrightRelatedOptions,
+  ProjectOptions,
+  QueueReport,
+  ReactComponentFacts,
+  ReactViolation,
+  ServerRoutesReport,
+  SymbolsOptions,
+  SymbolsResult,
+  TestGraph,
+  TestPlan,
+  TestsPlanDocumentOptions,
+  TestsPlanOptions,
+  TestsWhyOptions,
+  TraverseOptions,
+  WhyStep,
+} from "./types";
+
+export * from "./types";
+
+export function dependencies(options: TraverseOptions): Promise<DependencyResult>;
+export function dependents(options: TraverseOptions): Promise<DependencyResult>;
+export function related(options: TraverseOptions): Promise<DependencyResult>;
+export function symbols(options: SymbolsOptions): Promise<SymbolsResult>;
+export function fetches(options?: FetchesOptions): Promise<unknown>;
+export function check(options?: ProjectOptions): Promise<CheckReport>;
+export function testsPlan(options: TestsPlanOptions): Promise<TestPlan>;
+export function testsWhy(options: TestsWhyOptions): Promise<Record<string, WhyStep[]>>;
+export function testsComment(options: TestsPlanDocumentOptions): Promise<string>;
+export function testsGraph(options: TestsPlanDocumentOptions): Promise<TestGraph>;
+export function testsGraphMermaid(options: TestsPlanDocumentOptions): Promise<string>;
+export function playwrightCheck(options?: PlaywrightOptions): Promise<unknown>;
+export function playwrightEdges(options?: PlaywrightOptions): Promise<unknown>;
+export function playwrightRelated(options: PlaywrightRelatedOptions): Promise<unknown>;
+export function playwrightTests(options?: PlaywrightOptions): Promise<unknown>;
+export function queues(options?: ProjectOptions): Promise<QueueReport>;
+export function queueEdges(options?: ProjectOptions): Promise<GraphEdge[]>;
+export function queueRelated(options: ProjectOptions): Promise<GraphEdge[]>;
+export function queueCheck(options?: ProjectOptions): Promise<unknown[]>;
+export function serverRoutes(options?: ProjectOptions): Promise<ServerRoutesReport>;
+export function serverRouteList(options?: ProjectOptions): Promise<unknown[]>;
+export function serverRouteEdges(options?: ProjectOptions): Promise<GraphEdge[]>;
+export function serverRouteRelated(options: ProjectOptions): Promise<GraphEdge[]>;
+export function reactAnalyze(options?: ProjectOptions): Promise<ReactComponentFacts[]>;
+export function reactCheck(options?: ProjectOptions): Promise<ReactViolation[]>;
+export function version(): Promise<string>;

package/index.js

@@ -0,0 +1,140 @@
+"use strict";
+
+const native = require("./bin/no-mistakes.node");
+
+async function callJson(fn, options) {
+  return JSON.parse(await fn(JSON.stringify(options || {})));
+}
+
+async function dependencies(options) {
+  return callJson(native.dependenciesJson, options);
+}
+
+async function dependents(options) {
+  return callJson(native.dependentsJson, options);
+}
+
+async function related(options) {
+  return callJson(native.relatedJson, options);
+}
+
+async function symbols(options) {
+  return callJson(native.symbolsJson, options);
+}
+
+async function fetches(options) {
+  return callJson(native.fetchesJson, options);
+}
+
+async function check(options) {
+  return callJson(native.checkJson, options);
+}
+
+async function testsPlan(options) {
+  return callJson(native.testsPlanJson, options);
+}
+
+async function testsWhy(options) {
+  return callJson(native.testsWhyJson, options);
+}
+
+async function testsComment(options) {
+  return native.testsCommentMarkdown(JSON.stringify(options || {}));
+}
+
+async function testsGraph(options) {
+  return callJson(native.testsGraphJson, options);
+}
+
+async function testsGraphMermaid(options) {
+  return native.testsGraphMermaid(JSON.stringify(options || {}));
+}
+
+async function playwrightCheck(options) {
+  return callJson(native.playwrightCheckJson, options);
+}
+
+async function playwrightEdges(options) {
+  return callJson(native.playwrightEdgesJson, options);
+}
+
+async function playwrightRelated(options) {
+  return callJson(native.playwrightRelatedJson, options);
+}
+
+async function playwrightTests(options) {
+  return callJson(native.playwrightTestsJson, options);
+}
+
+async function queues(options) {
+  return callJson(native.queuesJson, options);
+}
+
+async function queueEdges(options) {
+  return callJson(native.queueEdgesJson, options);
+}
+
+async function queueRelated(options) {
+  return callJson(native.queueRelatedJson, options);
+}
+
+async function queueCheck(options) {
+  return callJson(native.queueCheckJson, options);
+}
+
+async function serverRoutes(options) {
+  return callJson(native.serverRoutesJson, options);
+}
+
+async function serverRouteList(options) {
+  return callJson(native.serverRouteListJson, options);
+}
+
+async function serverRouteEdges(options) {
+  return callJson(native.serverRouteEdgesJson, options);
+}
+
+async function serverRouteRelated(options) {
+  return callJson(native.serverRouteRelatedJson, options);
+}
+
+async function reactAnalyze(options) {
+  return callJson(native.reactAnalyzeJson, options);
+}
+
+async function reactCheck(options) {
+  return callJson(native.reactCheckJson, options);
+}
+
+async function version() {
+  return native.version();
+}
+
+module.exports = {
+  check,
+  dependencies,
+  dependents,
+  fetches,
+  playwrightCheck,
+  playwrightEdges,
+  playwrightRelated,
+  playwrightTests,
+  queues,
+  queueCheck,
+  queueEdges,
+  queueRelated,
+  reactAnalyze,
+  reactCheck,
+  related,
+  serverRouteEdges,
+  serverRouteList,
+  serverRouteRelated,
+  serverRoutes,
+  symbols,
+  testsComment,
+  testsGraph,
+  testsGraphMermaid,
+  testsPlan,
+  testsWhy,
+  version,
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "no-mistakes",
-  "version": "0.8.0",
+  "version": "0.9.1",
   "description": "Static codebase analysis tools for TS/JS dependencies, dependents, and symbols",
   "license": "MIT",
   "repository": {
@@ -13,11 +13,15 @@
   },
   "files": [
     "bin/",
+    "*.d.ts",
+    "index.js",
     "scripts/install.js",
     "scripts/install/",
     "README.md",
     "LICENSE"
   ],
+  "main": "index.js",
+  "types": "index.d.ts",
   "publishConfig": {
     "access": "public"
   },

package/report-types.d.ts

@@ -0,0 +1,73 @@
+export interface PlaywrightOptions {
+  root?: string;
+  config?: string;
+  playwrightConfig?: string[];
+  project?: string;
+  files?: string[];
+  assertConditionalTests?: boolean;
+  allowSkippedTests?: boolean;
+  assertUniqueTestIds?: boolean;
+  assertUniqueHtmlIds?: boolean;
+  assertUniqueSelectors?: boolean;
+}
+
+export interface PlaywrightRelatedOptions extends PlaywrightOptions {
+  files: string[];
+}
+
+export interface CheckReport {
+  react: ReactViolation[];
+  queues: unknown[];
+  rules: unknown[];
+  integration: unknown[];
+  codebase: unknown[];
+}
+
+export interface QueueReport {
+  producers: unknown[];
+  workers: unknown[];
+  jobs: unknown[];
+  edges: unknown[];
+  diagnostics: unknown[];
+  check: unknown[];
+}
+
+export interface GraphEdge {
+  from: string;
+  to: string;
+  kind: string;
+}
+
+export interface ServerRoutesReport {
+  summary: {
+    totalRoutes: number;
+    totalFiles: number;
+    dynamicRoutes: number;
+  };
+  routes: unknown[];
+  edges: unknown[];
+  diagnostics: unknown[];
+}
+
+export interface ReactComponentFacts {
+  name: string;
+  file: string;
+  environment: "server" | "client" | "shared" | "unknown";
+  hasState: boolean;
+  hasProps: boolean;
+  passesProps: boolean;
+  usesMemo: boolean;
+  usesContextProvider: boolean;
+  usesSuspense: boolean;
+  fetches: unknown[];
+  dependencies: string[];
+  children: unknown[];
+  inheritedFromChildren?: unknown;
+}
+
+export interface ReactViolation {
+  component: string;
+  file: string;
+  rule: string;
+  detail?: string;
+}

package/scripts/install/assets.js

@@ -2,8 +2,8 @@
 
 const { basename } = require("node:path");
 
-function assetName(binName, version, target) {
-  const ext = target.endsWith("windows-msvc") ? ".exe" : "";
+function assetName(binName, version, target, assetExtension) {
+  const ext = assetExtension ?? (target.endsWith("windows-msvc") ? ".exe" : "");
   return `${binName}-v${version}-${target}${ext}`;
 }
 

package/scripts/install/installer.js

@@ -52,7 +52,7 @@ async function install(binName, repository, options = {}) {
     return destination;
   }
 
-  const asset = assetName(binName, version, target);
+  const asset = assetName(binName, version, target, options.assetExtension);
   const baseUrl = options.baseUrl || releaseBaseUrl(repository, version, options.envVar);
   const temp = `${destination}.tmp-${process.pid}`;
 

package/scripts/install.js

@@ -9,14 +9,24 @@ const PACKAGE_ROOT = join(__dirname, "..");
 async function main(installFn = install, io = process, logger = console) {
   try {
     const pkg = require(join(PACKAGE_ROOT, "package.json"));
-    const destination = await installFn("no-mistakes", "jonathanong/no-mistakes", {
+    const binDir = join(PACKAGE_ROOT, "bin");
+    const binaryDestination = await installFn("no-mistakes", "jonathanong/no-mistakes", {
       version: pkg.version,
-      vendorDir: join(PACKAGE_ROOT, "bin"),
+      vendorDir: binDir,
       destinationName: "no-mistakes",
       envVar: "NO_MISTAKES_RELEASE_BASE_URL",
       checkExisting: true,
     });
-    logger.log(`Installed no-mistakes native binary to ${destination}`);
+    const addonDestination = await installFn("no-mistakes-napi", "jonathanong/no-mistakes", {
+      version: pkg.version,
+      vendorDir: binDir,
+      destinationName: "no-mistakes.node",
+      assetExtension: ".node",
+      envVar: "NO_MISTAKES_RELEASE_BASE_URL",
+      checkExisting: true,
+    });
+    logger.log(`Installed no-mistakes native binary to ${binaryDestination}`);
+    logger.log(`Installed no-mistakes N-API addon to ${addonDestination}`);
   } catch (error) {
     logger.error(error instanceof Error ? error.message : String(error));
     io.exit(1);

package/test-types.d.ts

@@ -0,0 +1,70 @@
+export interface TestsPlanOptions {
+  framework?: "vitest" | "playwright";
+  root?: string;
+  config?: string;
+  tsconfig?: string;
+  base?: string;
+  head?: string;
+  changedFiles?: string[];
+  changedFilesFile?: string;
+  environment?: string;
+  limitPercent?: number;
+  limitFiles?: number;
+}
+
+export interface TestPlan {
+  selected_tests: SelectedTest[];
+  groups?: TestPlanGroup[];
+  warnings: TestPlanWarning[];
+  fallback_triggered: boolean;
+  fallback_reason?: string | null;
+}
+
+export interface SelectedTest {
+  test_file: string;
+  confidence: "low" | "medium" | "high";
+  reasons: ImpactReason[];
+}
+
+export interface ImpactReason {
+  changed_file: string;
+  path: string[];
+  via: string[];
+}
+
+export interface TestPlanGroup {
+  type: string;
+  selected: string[];
+  remaining: number;
+  limit?: number | null;
+}
+
+export interface TestPlanWarning {
+  type: string;
+  message: string;
+  file: string;
+}
+
+export interface TestsWhyOptions {
+  root?: string;
+  config?: string;
+  tsconfig?: string;
+  test: string;
+  changed?: string;
+  plan?: string;
+}
+
+export interface WhyStep {
+  node: string;
+  via?: string | null;
+}
+
+export interface TestsPlanDocumentOptions {
+  plan?: string;
+  planJson?: TestPlan | string;
+}
+
+export interface TestGraph {
+  nodes: Array<{ name: string; type: "changed" | "test" | "intermediate" }>;
+  edges: Array<{ from: string; to: string; via: string }>;
+}

package/traversal-types.d.ts

@@ -0,0 +1,113 @@
+export type Relationship =
+  | "import"
+  | "import-static"
+  | "import-dynamic"
+  | "import-type"
+  | "import-require"
+  | "workspace"
+  | "package"
+  | "test"
+  | "route"
+  | "queue"
+  | "md"
+  | "ci"
+  | "http"
+  | "process"
+  | "asset"
+  | "react"
+  | "all";
+
+export interface TraverseOptions {
+  files: string[];
+  root?: string;
+  tsconfig?: string;
+  depth?: number;
+  filters?: string[];
+  targetModules?: string[];
+  tests?: string[];
+  relationships?: Relationship[];
+}
+
+export interface DependencyFile {
+  path?: string;
+  queueFile?: string;
+  job?: string;
+  module?: string;
+  depth: number;
+  via?: string[];
+}
+
+export interface DependencyResult {
+  roots: string[];
+  files: DependencyFile[];
+}
+
+export type ExportKind =
+  | "function"
+  | "class"
+  | "const"
+  | "let"
+  | "var"
+  | "type"
+  | "interface"
+  | "enum"
+  | "default"
+  | "re-export";
+
+export interface SymbolsOptions {
+  files: string[];
+  root?: string;
+  tsconfig?: string;
+  kinds?: ExportKind[];
+  include?: "exports" | "imports" | "both";
+}
+
+export interface SymbolExport {
+  name: string;
+  kind: string;
+  line: number;
+  reExport?: {
+    source: string;
+    imported: string;
+    resolved?: string;
+  };
+}
+
+export interface SymbolImport {
+  source: string;
+  imported: string;
+  local: string;
+  line: number;
+  typeOnly: boolean;
+  resolved?: string;
+}
+
+export interface SymbolFile {
+  path: string;
+  exports?: SymbolExport[];
+  imports?: SymbolImport[];
+}
+
+export interface SymbolsResult {
+  roots: string[];
+  files: SymbolFile[];
+}
+
+export interface ProjectOptions {
+  root?: string;
+  tsconfig?: string;
+  config?: string;
+  filters?: string[];
+  targets?: string[];
+  files?: string[];
+  roots?: string[];
+  depth?: number;
+  assertNoFetch?: boolean;
+  direction?: "deps" | "dependents" | "both";
+}
+
+export interface FetchesOptions {
+  root?: string;
+  config?: string;
+  targets?: string[];
+}

package/types.d.ts

@@ -0,0 +1,3 @@
+export * from "./traversal-types";
+export * from "./test-types";
+export * from "./report-types";