@fallow-cli/fallow-node 2.47.0

package/README.md

@@ -0,0 +1,30 @@
+# @fallow-cli/fallow-node
+
+Native Node.js bindings for fallow’s main analyses.
+
+## Install
+
+```bash
+npm install @fallow-cli/fallow-node
+```
+
+## API
+
+- `detectDeadCode(options?)`
+- `detectCircularDependencies(options?)`
+- `detectBoundaryViolations(options?)`
+- `detectDuplication(options?)`
+- `computeComplexity(options?)`
+- `computeHealth(options?)`
+
+All functions are async and return the same JSON-shaped report contracts that the CLI emits for `--format json`.
+
+Enum-like option values use lowercase CLI-style strings such as `"mild"`, `"cyclomatic"`, `"handle"`, and `"low"`.
+
+Rejected promises throw a `FallowNodeError` with:
+
+- `message`
+- `exitCode`
+- optional `code`
+- optional `help`
+- optional `context`

package/index.d.ts

@@ -0,0 +1,362 @@
+export interface AnalysisOptions {
+  root?: string;
+  configPath?: string;
+  noCache?: boolean;
+  threads?: number;
+  production?: boolean;
+  changedSince?: string;
+  workspace?: string[];
+  changedWorkspaces?: string;
+  explain?: boolean;
+}
+
+export interface DeadCodeOptions extends AnalysisOptions {
+  unusedFiles?: boolean;
+  unusedExports?: boolean;
+  unusedDeps?: boolean;
+  unusedTypes?: boolean;
+  unusedEnumMembers?: boolean;
+  unusedClassMembers?: boolean;
+  unresolvedImports?: boolean;
+  unlistedDeps?: boolean;
+  duplicateExports?: boolean;
+  circularDeps?: boolean;
+  boundaryViolations?: boolean;
+  staleSuppressions?: boolean;
+  files?: string[];
+  includeEntryExports?: boolean;
+}
+
+export type DuplicationMode = 'strict' | 'mild' | 'weak' | 'semantic';
+
+export interface DuplicationOptions extends AnalysisOptions {
+  mode?: DuplicationMode;
+  minTokens?: number;
+  minLines?: number;
+  threshold?: number;
+  skipLocal?: boolean;
+  crossLanguage?: boolean;
+  ignoreImports?: boolean;
+  top?: number;
+}
+
+export type ComplexitySort = 'cyclomatic' | 'cognitive' | 'lines';
+export type OwnershipEmailMode = 'raw' | 'handle' | 'hash';
+export type TargetEffort = 'low' | 'medium' | 'high';
+
+export interface ComplexityOptions extends AnalysisOptions {
+  maxCyclomatic?: number;
+  maxCognitive?: number;
+  maxCrap?: number;
+  top?: number;
+  sort?: ComplexitySort;
+  complexity?: boolean;
+  fileScores?: boolean;
+  coverageGaps?: boolean;
+  hotspots?: boolean;
+  ownership?: boolean;
+  ownershipEmails?: OwnershipEmailMode;
+  targets?: boolean;
+  effort?: TargetEffort;
+  score?: boolean;
+  since?: string;
+  minCommits?: number;
+  coverage?: string;
+  coverageRoot?: string;
+}
+
+export interface AnalysisAction {
+  type?: string;
+  auto_fixable?: boolean;
+  description?: string;
+  comment?: string;
+  note?: string;
+  [key: string]: unknown;
+}
+
+export interface DeadCodeSummary {
+  total_issues: number;
+  unused_files: number;
+  unused_exports: number;
+  unused_types: number;
+  unused_dependencies: number;
+  unused_enum_members: number;
+  unused_class_members: number;
+  unresolved_imports: number;
+  unlisted_dependencies: number;
+  duplicate_exports: number;
+  type_only_dependencies: number;
+  test_only_dependencies: number;
+  circular_dependencies: number;
+  boundary_violations: number;
+  stale_suppressions: number;
+}
+
+export interface EntryPointSummary {
+  total: number;
+  sources: Record<string, number>;
+}
+
+export interface UnusedFileFinding {
+  path: string;
+  actions?: AnalysisAction[];
+  [key: string]: unknown;
+}
+
+export interface UnusedExportFinding {
+  path: string;
+  export_name: string;
+  line: number;
+  col: number;
+  actions?: AnalysisAction[];
+  [key: string]: unknown;
+}
+
+export interface UnusedDependencyFinding {
+  path: string;
+  package_name: string;
+  line: number;
+  col: number;
+  actions?: AnalysisAction[];
+  [key: string]: unknown;
+}
+
+export interface UnusedMemberFinding {
+  path: string;
+  parent_name: string;
+  member_name: string;
+  line: number;
+  col: number;
+  actions?: AnalysisAction[];
+  [key: string]: unknown;
+}
+
+export interface UnresolvedImportFinding {
+  path: string;
+  specifier: string;
+  line: number;
+  col: number;
+  actions?: AnalysisAction[];
+  [key: string]: unknown;
+}
+
+export interface UnlistedDependencyFinding {
+  package_name: string;
+  imported_from: Array<{ path: string; line: number; [key: string]: unknown }>;
+  actions?: AnalysisAction[];
+  [key: string]: unknown;
+}
+
+export interface DuplicateExportFinding {
+  export_name: string;
+  locations: Array<{ path: string; line: number; [key: string]: unknown }>;
+  actions?: AnalysisAction[];
+  [key: string]: unknown;
+}
+
+export interface TypeOnlyDependencyFinding {
+  path: string;
+  package_name: string;
+  line: number;
+  col: number;
+  actions?: AnalysisAction[];
+  [key: string]: unknown;
+}
+
+export interface TestOnlyDependencyFinding {
+  path: string;
+  package_name: string;
+  line: number;
+  col: number;
+  actions?: AnalysisAction[];
+  [key: string]: unknown;
+}
+
+export interface CircularDependencyFinding {
+  files: string[];
+  length: number;
+  actions?: AnalysisAction[];
+  [key: string]: unknown;
+}
+
+export interface BoundaryViolationFinding {
+  from_path: string;
+  to_path: string;
+  line: number;
+  col: number;
+  from_zone?: string;
+  to_zone?: string;
+  actions?: AnalysisAction[];
+  [key: string]: unknown;
+}
+
+export interface StaleSuppressionFinding {
+  path: string;
+  line: number;
+  col: number;
+  issue_kind?: string;
+  actions?: AnalysisAction[];
+  [key: string]: unknown;
+}
+
+export interface DeadCodeReport {
+  schema_version: number;
+  version: string;
+  elapsed_ms: number;
+  total_issues: number;
+  summary: DeadCodeSummary;
+  entry_points?: EntryPointSummary;
+  unused_files: UnusedFileFinding[];
+  unused_exports: UnusedExportFinding[];
+  unused_types: UnusedExportFinding[];
+  unused_dependencies: UnusedDependencyFinding[];
+  unused_dev_dependencies: UnusedDependencyFinding[];
+  unused_optional_dependencies: UnusedDependencyFinding[];
+  unused_enum_members: UnusedMemberFinding[];
+  unused_class_members: UnusedMemberFinding[];
+  unresolved_imports: UnresolvedImportFinding[];
+  unlisted_dependencies: UnlistedDependencyFinding[];
+  duplicate_exports: DuplicateExportFinding[];
+  type_only_dependencies: TypeOnlyDependencyFinding[];
+  test_only_dependencies: TestOnlyDependencyFinding[];
+  circular_dependencies: CircularDependencyFinding[];
+  boundary_violations: BoundaryViolationFinding[];
+  stale_suppressions: StaleSuppressionFinding[];
+  _meta?: Record<string, unknown>;
+}
+
+export interface CloneInstance {
+  file: string;
+  start_line: number;
+  end_line: number;
+  start_col: number;
+  end_col: number;
+  fragment?: string;
+  [key: string]: unknown;
+}
+
+export interface CloneGroup {
+  instances: CloneInstance[];
+  token_count: number;
+  line_count: number;
+  actions?: AnalysisAction[];
+  [key: string]: unknown;
+}
+
+export interface DuplicationStats {
+  total_files: number;
+  files_with_clones: number;
+  total_lines: number;
+  duplicated_lines: number;
+  total_tokens: number;
+  duplicated_tokens: number;
+  clone_groups: number;
+  clone_instances: number;
+  duplication_percentage: number;
+}
+
+export interface DuplicationReport {
+  schema_version: number;
+  version: string;
+  elapsed_ms: number;
+  clone_groups: CloneGroup[];
+  clone_families?: Record<string, unknown>[];
+  mirrored_directories?: Record<string, unknown>[];
+  stats: DuplicationStats;
+  _meta?: Record<string, unknown>;
+}
+
+export interface HealthFinding {
+  path: string;
+  name: string;
+  line: number;
+  col: number;
+  cyclomatic: number;
+  cognitive: number;
+  line_count: number;
+  param_count: number;
+  exceeded: string;
+  severity: string;
+  crap?: number;
+  coverage_pct?: number;
+  actions?: AnalysisAction[];
+  [key: string]: unknown;
+}
+
+export interface FileHealthScore {
+  path: string;
+  fan_in: number;
+  fan_out: number;
+  dead_code_ratio: number;
+  complexity_density: number;
+  maintainability_index: number;
+  total_cyclomatic: number;
+  total_cognitive: number;
+  function_count: number;
+  lines: number;
+  crap_max: number;
+  crap_above_threshold: number;
+  [key: string]: unknown;
+}
+
+export interface CoverageGaps {
+  summary: {
+    runtime_files: number;
+    covered_files: number;
+    file_coverage_pct: number;
+    untested_files: number;
+    untested_exports: number;
+  };
+  files?: Array<{ path: string; value_export_count: number; [key: string]: unknown }>;
+  exports?: Array<{ path: string; export_name: string; line: number; col: number; [key: string]: unknown }>;
+}
+
+export interface RefactoringTarget {
+  path: string;
+  priority: number;
+  efficiency: number;
+  recommendation: string;
+  category: string;
+  effort: string;
+  confidence: string;
+  factors?: Array<Record<string, unknown>>;
+  evidence?: Record<string, unknown>;
+  [key: string]: unknown;
+}
+
+export interface HealthReport {
+  schema_version: number;
+  version: string;
+  elapsed_ms: number;
+  findings: HealthFinding[];
+  summary: Record<string, unknown>;
+  vital_signs?: Record<string, unknown>;
+  health_score?: Record<string, unknown>;
+  file_scores?: FileHealthScore[];
+  coverage_gaps?: CoverageGaps;
+  hotspots?: Array<Record<string, unknown>>;
+  hotspot_summary?: Record<string, unknown>;
+  production_coverage?: Record<string, unknown>;
+  large_functions?: Array<Record<string, unknown>>;
+  targets?: RefactoringTarget[];
+  target_thresholds?: Record<string, unknown>;
+  health_trend?: Record<string, unknown>;
+  _meta?: Record<string, unknown>;
+}
+
+export interface FallowNodeErrorShape {
+  message: string;
+  exitCode: number;
+  code?: string;
+  help?: string;
+  context?: string;
+}
+
+export type FallowNodeError = Error & FallowNodeErrorShape;
+
+export function detectDeadCode(options?: DeadCodeOptions): Promise<DeadCodeReport>;
+export function detectCircularDependencies(options?: DeadCodeOptions): Promise<DeadCodeReport>;
+export function detectBoundaryViolations(options?: DeadCodeOptions): Promise<DeadCodeReport>;
+export function detectDuplication(options?: DuplicationOptions): Promise<DuplicationReport>;
+export function computeComplexity(options?: ComplexityOptions): Promise<HealthReport>;
+export function computeHealth(options?: ComplexityOptions): Promise<HealthReport>;

package/index.js

@@ -0,0 +1,584 @@
+// prettier-ignore
+/* eslint-disable */
+// @ts-nocheck
+/* auto-generated by NAPI-RS */
+
+const { readFileSync } = require('node:fs')
+let nativeBinding = null
+const loadErrors = []
+
+const isMusl = () => {
+  let musl = false
+  if (process.platform === 'linux') {
+    musl = isMuslFromFilesystem()
+    if (musl === null) {
+      musl = isMuslFromReport()
+    }
+    if (musl === null) {
+      musl = isMuslFromChildProcess()
+    }
+  }
+  return musl
+}
+
+const isFileMusl = (f) => f.includes('libc.musl-') || f.includes('ld-musl-')
+
+const isMuslFromFilesystem = () => {
+  try {
+    return readFileSync('/usr/bin/ldd', 'utf-8').includes('musl')
+  } catch {
+    return null
+  }
+}
+
+const isMuslFromReport = () => {
+  let report = null
+  if (typeof process.report?.getReport === 'function') {
+    process.report.excludeNetwork = true
+    report = process.report.getReport()
+  }
+  if (!report) {
+    return null
+  }
+  if (report.header && report.header.glibcVersionRuntime) {
+    return false
+  }
+  if (Array.isArray(report.sharedObjects)) {
+    if (report.sharedObjects.some(isFileMusl)) {
+      return true
+    }
+  }
+  return false
+}
+
+const isMuslFromChildProcess = () => {
+  try {
+    return require('child_process').execSync('ldd --version', { encoding: 'utf8' }).includes('musl')
+  } catch (e) {
+    // If we reach this case, we don't know if the system is musl or not, so is better to just fallback to false
+    return false
+  }
+}
+
+function requireNative() {
+  if (process.env.NAPI_RS_NATIVE_LIBRARY_PATH) {
+    try {
+      return require(process.env.NAPI_RS_NATIVE_LIBRARY_PATH);
+    } catch (err) {
+      loadErrors.push(err)
+    }
+  } else if (process.platform === 'android') {
+    if (process.arch === 'arm64') {
+      try {
+        return require('./fallow-node.android-arm64.node')
+      } catch (e) {
+        loadErrors.push(e)
+      }
+      try {
+        const binding = require('@fallow-cli/fallow-node-android-arm64')
+        const bindingPackageVersion = require('@fallow-cli/fallow-node-android-arm64/package.json').version
+        if (bindingPackageVersion !== '2.47.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+          throw new Error(`Native binding package version mismatch, expected 2.47.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+        }
+        return binding
+      } catch (e) {
+        loadErrors.push(e)
+      }
+    } else if (process.arch === 'arm') {
+      try {
+        return require('./fallow-node.android-arm-eabi.node')
+      } catch (e) {
+        loadErrors.push(e)
+      }
+      try {
+        const binding = require('@fallow-cli/fallow-node-android-arm-eabi')
+        const bindingPackageVersion = require('@fallow-cli/fallow-node-android-arm-eabi/package.json').version
+        if (bindingPackageVersion !== '2.47.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+          throw new Error(`Native binding package version mismatch, expected 2.47.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+        }
+        return binding
+      } catch (e) {
+        loadErrors.push(e)
+      }
+    } else {
+      loadErrors.push(new Error(`Unsupported architecture on Android ${process.arch}`))
+    }
+  } else if (process.platform === 'win32') {
+    if (process.arch === 'x64') {
+      if (process.config?.variables?.shlib_suffix === 'dll.a' || process.config?.variables?.node_target_type === 'shared_library') {
+        try {
+        return require('./fallow-node.win32-x64-gnu.node')
+      } catch (e) {
+        loadErrors.push(e)
+      }
+      try {
+        const binding = require('@fallow-cli/fallow-node-win32-x64-gnu')
+        const bindingPackageVersion = require('@fallow-cli/fallow-node-win32-x64-gnu/package.json').version
+        if (bindingPackageVersion !== '2.47.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+          throw new Error(`Native binding package version mismatch, expected 2.47.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+        }
+        return binding
+      } catch (e) {
+        loadErrors.push(e)
+      }
+      } else {
+        try {
+        return require('./fallow-node.win32-x64-msvc.node')
+      } catch (e) {
+        loadErrors.push(e)
+      }
+      try {
+        const binding = require('@fallow-cli/fallow-node-win32-x64-msvc')
+        const bindingPackageVersion = require('@fallow-cli/fallow-node-win32-x64-msvc/package.json').version
+        if (bindingPackageVersion !== '2.47.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+          throw new Error(`Native binding package version mismatch, expected 2.47.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+        }
+        return binding
+      } catch (e) {
+        loadErrors.push(e)
+      }
+      }
+    } else if (process.arch === 'ia32') {
+      try {
+        return require('./fallow-node.win32-ia32-msvc.node')
+      } catch (e) {
+        loadErrors.push(e)
+      }
+      try {
+        const binding = require('@fallow-cli/fallow-node-win32-ia32-msvc')
+        const bindingPackageVersion = require('@fallow-cli/fallow-node-win32-ia32-msvc/package.json').version
+        if (bindingPackageVersion !== '2.47.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+          throw new Error(`Native binding package version mismatch, expected 2.47.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+        }
+        return binding
+      } catch (e) {
+        loadErrors.push(e)
+      }
+    } else if (process.arch === 'arm64') {
+      try {
+        return require('./fallow-node.win32-arm64-msvc.node')
+      } catch (e) {
+        loadErrors.push(e)
+      }
+      try {
+        const binding = require('@fallow-cli/fallow-node-win32-arm64-msvc')
+        const bindingPackageVersion = require('@fallow-cli/fallow-node-win32-arm64-msvc/package.json').version
+        if (bindingPackageVersion !== '2.47.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+          throw new Error(`Native binding package version mismatch, expected 2.47.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+        }
+        return binding
+      } catch (e) {
+        loadErrors.push(e)
+      }
+    } else {
+      loadErrors.push(new Error(`Unsupported architecture on Windows: ${process.arch}`))
+    }
+  } else if (process.platform === 'darwin') {
+    try {
+      return require('./fallow-node.darwin-universal.node')
+    } catch (e) {
+      loadErrors.push(e)
+    }
+    try {
+      const binding = require('@fallow-cli/fallow-node-darwin-universal')
+      const bindingPackageVersion = require('@fallow-cli/fallow-node-darwin-universal/package.json').version
+      if (bindingPackageVersion !== '2.47.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+        throw new Error(`Native binding package version mismatch, expected 2.47.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+      }
+      return binding
+    } catch (e) {
+      loadErrors.push(e)
+    }
+    if (process.arch === 'x64') {
+      try {
+        return require('./fallow-node.darwin-x64.node')
+      } catch (e) {
+        loadErrors.push(e)
+      }
+      try {
+        const binding = require('@fallow-cli/fallow-node-darwin-x64')
+        const bindingPackageVersion = require('@fallow-cli/fallow-node-darwin-x64/package.json').version
+        if (bindingPackageVersion !== '2.47.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+          throw new Error(`Native binding package version mismatch, expected 2.47.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+        }
+        return binding
+      } catch (e) {
+        loadErrors.push(e)
+      }
+    } else if (process.arch === 'arm64') {
+      try {
+        return require('./fallow-node.darwin-arm64.node')
+      } catch (e) {
+        loadErrors.push(e)
+      }
+      try {
+        const binding = require('@fallow-cli/fallow-node-darwin-arm64')
+        const bindingPackageVersion = require('@fallow-cli/fallow-node-darwin-arm64/package.json').version
+        if (bindingPackageVersion !== '2.47.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+          throw new Error(`Native binding package version mismatch, expected 2.47.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+        }
+        return binding
+      } catch (e) {
+        loadErrors.push(e)
+      }
+    } else {
+      loadErrors.push(new Error(`Unsupported architecture on macOS: ${process.arch}`))
+    }
+  } else if (process.platform === 'freebsd') {
+    if (process.arch === 'x64') {
+      try {
+        return require('./fallow-node.freebsd-x64.node')
+      } catch (e) {
+        loadErrors.push(e)
+      }
+      try {
+        const binding = require('@fallow-cli/fallow-node-freebsd-x64')
+        const bindingPackageVersion = require('@fallow-cli/fallow-node-freebsd-x64/package.json').version
+        if (bindingPackageVersion !== '2.47.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+          throw new Error(`Native binding package version mismatch, expected 2.47.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+        }
+        return binding
+      } catch (e) {
+        loadErrors.push(e)
+      }
+    } else if (process.arch === 'arm64') {
+      try {
+        return require('./fallow-node.freebsd-arm64.node')
+      } catch (e) {
+        loadErrors.push(e)
+      }
+      try {
+        const binding = require('@fallow-cli/fallow-node-freebsd-arm64')
+        const bindingPackageVersion = require('@fallow-cli/fallow-node-freebsd-arm64/package.json').version
+        if (bindingPackageVersion !== '2.47.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+          throw new Error(`Native binding package version mismatch, expected 2.47.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+        }
+        return binding
+      } catch (e) {
+        loadErrors.push(e)
+      }
+    } else {
+      loadErrors.push(new Error(`Unsupported architecture on FreeBSD: ${process.arch}`))
+    }
+  } else if (process.platform === 'linux') {
+    if (process.arch === 'x64') {
+      if (isMusl()) {
+        try {
+          return require('./fallow-node.linux-x64-musl.node')
+        } catch (e) {
+          loadErrors.push(e)
+        }
+        try {
+          const binding = require('@fallow-cli/fallow-node-linux-x64-musl')
+          const bindingPackageVersion = require('@fallow-cli/fallow-node-linux-x64-musl/package.json').version
+          if (bindingPackageVersion !== '2.47.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+            throw new Error(`Native binding package version mismatch, expected 2.47.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+          }
+          return binding
+        } catch (e) {
+          loadErrors.push(e)
+        }
+      } else {
+        try {
+          return require('./fallow-node.linux-x64-gnu.node')
+        } catch (e) {
+          loadErrors.push(e)
+        }
+        try {
+          const binding = require('@fallow-cli/fallow-node-linux-x64-gnu')
+          const bindingPackageVersion = require('@fallow-cli/fallow-node-linux-x64-gnu/package.json').version
+          if (bindingPackageVersion !== '2.47.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+            throw new Error(`Native binding package version mismatch, expected 2.47.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+          }
+          return binding
+        } catch (e) {
+          loadErrors.push(e)
+        }
+      }
+    } else if (process.arch === 'arm64') {
+      if (isMusl()) {
+        try {
+          return require('./fallow-node.linux-arm64-musl.node')
+        } catch (e) {
+          loadErrors.push(e)
+        }
+        try {
+          const binding = require('@fallow-cli/fallow-node-linux-arm64-musl')
+          const bindingPackageVersion = require('@fallow-cli/fallow-node-linux-arm64-musl/package.json').version
+          if (bindingPackageVersion !== '2.47.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+            throw new Error(`Native binding package version mismatch, expected 2.47.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+          }
+          return binding
+        } catch (e) {
+          loadErrors.push(e)
+        }
+      } else {
+        try {
+          return require('./fallow-node.linux-arm64-gnu.node')
+        } catch (e) {
+          loadErrors.push(e)
+        }
+        try {
+          const binding = require('@fallow-cli/fallow-node-linux-arm64-gnu')
+          const bindingPackageVersion = require('@fallow-cli/fallow-node-linux-arm64-gnu/package.json').version
+          if (bindingPackageVersion !== '2.47.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+            throw new Error(`Native binding package version mismatch, expected 2.47.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+          }
+          return binding
+        } catch (e) {
+          loadErrors.push(e)
+        }
+      }
+    } else if (process.arch === 'arm') {
+      if (isMusl()) {
+        try {
+          return require('./fallow-node.linux-arm-musleabihf.node')
+        } catch (e) {
+          loadErrors.push(e)
+        }
+        try {
+          const binding = require('@fallow-cli/fallow-node-linux-arm-musleabihf')
+          const bindingPackageVersion = require('@fallow-cli/fallow-node-linux-arm-musleabihf/package.json').version
+          if (bindingPackageVersion !== '2.47.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+            throw new Error(`Native binding package version mismatch, expected 2.47.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+          }
+          return binding
+        } catch (e) {
+          loadErrors.push(e)
+        }
+      } else {
+        try {
+          return require('./fallow-node.linux-arm-gnueabihf.node')
+        } catch (e) {
+          loadErrors.push(e)
+        }
+        try {
+          const binding = require('@fallow-cli/fallow-node-linux-arm-gnueabihf')
+          const bindingPackageVersion = require('@fallow-cli/fallow-node-linux-arm-gnueabihf/package.json').version
+          if (bindingPackageVersion !== '2.47.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+            throw new Error(`Native binding package version mismatch, expected 2.47.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+          }
+          return binding
+        } catch (e) {
+          loadErrors.push(e)
+        }
+      }
+    } else if (process.arch === 'loong64') {
+      if (isMusl()) {
+        try {
+          return require('./fallow-node.linux-loong64-musl.node')
+        } catch (e) {
+          loadErrors.push(e)
+        }
+        try {
+          const binding = require('@fallow-cli/fallow-node-linux-loong64-musl')
+          const bindingPackageVersion = require('@fallow-cli/fallow-node-linux-loong64-musl/package.json').version
+          if (bindingPackageVersion !== '2.47.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+            throw new Error(`Native binding package version mismatch, expected 2.47.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+          }
+          return binding
+        } catch (e) {
+          loadErrors.push(e)
+        }
+      } else {
+        try {
+          return require('./fallow-node.linux-loong64-gnu.node')
+        } catch (e) {
+          loadErrors.push(e)
+        }
+        try {
+          const binding = require('@fallow-cli/fallow-node-linux-loong64-gnu')
+          const bindingPackageVersion = require('@fallow-cli/fallow-node-linux-loong64-gnu/package.json').version
+          if (bindingPackageVersion !== '2.47.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+            throw new Error(`Native binding package version mismatch, expected 2.47.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+          }
+          return binding
+        } catch (e) {
+          loadErrors.push(e)
+        }
+      }
+    } else if (process.arch === 'riscv64') {
+      if (isMusl()) {
+        try {
+          return require('./fallow-node.linux-riscv64-musl.node')
+        } catch (e) {
+          loadErrors.push(e)
+        }
+        try {
+          const binding = require('@fallow-cli/fallow-node-linux-riscv64-musl')
+          const bindingPackageVersion = require('@fallow-cli/fallow-node-linux-riscv64-musl/package.json').version
+          if (bindingPackageVersion !== '2.47.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+            throw new Error(`Native binding package version mismatch, expected 2.47.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+          }
+          return binding
+        } catch (e) {
+          loadErrors.push(e)
+        }
+      } else {
+        try {
+          return require('./fallow-node.linux-riscv64-gnu.node')
+        } catch (e) {
+          loadErrors.push(e)
+        }
+        try {
+          const binding = require('@fallow-cli/fallow-node-linux-riscv64-gnu')
+          const bindingPackageVersion = require('@fallow-cli/fallow-node-linux-riscv64-gnu/package.json').version
+          if (bindingPackageVersion !== '2.47.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+            throw new Error(`Native binding package version mismatch, expected 2.47.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+          }
+          return binding
+        } catch (e) {
+          loadErrors.push(e)
+        }
+      }
+    } else if (process.arch === 'ppc64') {
+      try {
+        return require('./fallow-node.linux-ppc64-gnu.node')
+      } catch (e) {
+        loadErrors.push(e)
+      }
+      try {
+        const binding = require('@fallow-cli/fallow-node-linux-ppc64-gnu')
+        const bindingPackageVersion = require('@fallow-cli/fallow-node-linux-ppc64-gnu/package.json').version
+        if (bindingPackageVersion !== '2.47.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+          throw new Error(`Native binding package version mismatch, expected 2.47.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+        }
+        return binding
+      } catch (e) {
+        loadErrors.push(e)
+      }
+    } else if (process.arch === 's390x') {
+      try {
+        return require('./fallow-node.linux-s390x-gnu.node')
+      } catch (e) {
+        loadErrors.push(e)
+      }
+      try {
+        const binding = require('@fallow-cli/fallow-node-linux-s390x-gnu')
+        const bindingPackageVersion = require('@fallow-cli/fallow-node-linux-s390x-gnu/package.json').version
+        if (bindingPackageVersion !== '2.47.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+          throw new Error(`Native binding package version mismatch, expected 2.47.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+        }
+        return binding
+      } catch (e) {
+        loadErrors.push(e)
+      }
+    } else {
+      loadErrors.push(new Error(`Unsupported architecture on Linux: ${process.arch}`))
+    }
+  } else if (process.platform === 'openharmony') {
+    if (process.arch === 'arm64') {
+      try {
+        return require('./fallow-node.openharmony-arm64.node')
+      } catch (e) {
+        loadErrors.push(e)
+      }
+      try {
+        const binding = require('@fallow-cli/fallow-node-openharmony-arm64')
+        const bindingPackageVersion = require('@fallow-cli/fallow-node-openharmony-arm64/package.json').version
+        if (bindingPackageVersion !== '2.47.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+          throw new Error(`Native binding package version mismatch, expected 2.47.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+        }
+        return binding
+      } catch (e) {
+        loadErrors.push(e)
+      }
+    } else if (process.arch === 'x64') {
+      try {
+        return require('./fallow-node.openharmony-x64.node')
+      } catch (e) {
+        loadErrors.push(e)
+      }
+      try {
+        const binding = require('@fallow-cli/fallow-node-openharmony-x64')
+        const bindingPackageVersion = require('@fallow-cli/fallow-node-openharmony-x64/package.json').version
+        if (bindingPackageVersion !== '2.47.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+          throw new Error(`Native binding package version mismatch, expected 2.47.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+        }
+        return binding
+      } catch (e) {
+        loadErrors.push(e)
+      }
+    } else if (process.arch === 'arm') {
+      try {
+        return require('./fallow-node.openharmony-arm.node')
+      } catch (e) {
+        loadErrors.push(e)
+      }
+      try {
+        const binding = require('@fallow-cli/fallow-node-openharmony-arm')
+        const bindingPackageVersion = require('@fallow-cli/fallow-node-openharmony-arm/package.json').version
+        if (bindingPackageVersion !== '2.47.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+          throw new Error(`Native binding package version mismatch, expected 2.47.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+        }
+        return binding
+      } catch (e) {
+        loadErrors.push(e)
+      }
+    } else {
+      loadErrors.push(new Error(`Unsupported architecture on OpenHarmony: ${process.arch}`))
+    }
+  } else {
+    loadErrors.push(new Error(`Unsupported OS: ${process.platform}, architecture: ${process.arch}`))
+  }
+}
+
+nativeBinding = requireNative()
+
+if (!nativeBinding || process.env.NAPI_RS_FORCE_WASI) {
+  let wasiBinding = null
+  let wasiBindingError = null
+  try {
+    wasiBinding = require('./fallow-node.wasi.cjs')
+    nativeBinding = wasiBinding
+  } catch (err) {
+    if (process.env.NAPI_RS_FORCE_WASI) {
+      wasiBindingError = err
+    }
+  }
+  if (!nativeBinding || process.env.NAPI_RS_FORCE_WASI) {
+    try {
+      wasiBinding = require('@fallow-cli/fallow-node-wasm32-wasi')
+      nativeBinding = wasiBinding
+    } catch (err) {
+      if (process.env.NAPI_RS_FORCE_WASI) {
+        if (!wasiBindingError) {
+          wasiBindingError = err
+        } else {
+          wasiBindingError.cause = err
+        }
+        loadErrors.push(err)
+      }
+    }
+  }
+  if (process.env.NAPI_RS_FORCE_WASI === 'error' && !wasiBinding) {
+    const error = new Error('WASI binding not found and NAPI_RS_FORCE_WASI is set to error')
+    error.cause = wasiBindingError
+    throw error
+  }
+}
+
+if (!nativeBinding) {
+  if (loadErrors.length > 0) {
+    throw new Error(
+      `Cannot find native binding. ` +
+        `npm has a bug related to optional dependencies (https://github.com/npm/cli/issues/4828). ` +
+        'Please try `npm i` again after removing both package-lock.json and node_modules directory.',
+      {
+        cause: loadErrors.reduce((err, cur) => {
+          cur.cause = err
+          return cur
+        }),
+      },
+    )
+  }
+  throw new Error(`Failed to load native binding`)
+}
+
+module.exports = nativeBinding
+module.exports.computeComplexity = nativeBinding.computeComplexity
+module.exports.computeHealth = nativeBinding.computeHealth
+module.exports.detectBoundaryViolations = nativeBinding.detectBoundaryViolations
+module.exports.detectCircularDependencies = nativeBinding.detectCircularDependencies
+module.exports.detectDeadCode = nativeBinding.detectDeadCode
+module.exports.detectDuplication = nativeBinding.detectDuplication

package/package.json

@@ -0,0 +1,74 @@
+{
+  "name": "@fallow-cli/fallow-node",
+  "version": "2.47.0",
+  "description": "Native Node.js bindings for fallow dead-code, duplication, and health analyses.",
+  "main": "index.js",
+  "types": "index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./index.d.ts",
+      "default": "./index.js"
+    }
+  },
+  "files": [
+    "index.js",
+    "index.d.ts",
+    "README.md"
+  ],
+  "keywords": [
+    "fallow",
+    "typescript",
+    "javascript",
+    "dead-code",
+    "duplication",
+    "complexity",
+    "napi"
+  ],
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/fallow-rs/fallow.git",
+    "directory": "crates/napi"
+  },
+  "homepage": "https://docs.fallow.tools",
+  "bugs": {
+    "url": "https://github.com/fallow-rs/fallow/issues"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "napi": {
+    "binaryName": "fallow-node",
+    "packageName": "@fallow-cli/fallow-node",
+    "targets": [
+      "aarch64-apple-darwin",
+      "x86_64-apple-darwin",
+      "x86_64-unknown-linux-gnu",
+      "aarch64-unknown-linux-gnu",
+      "x86_64-unknown-linux-musl",
+      "aarch64-unknown-linux-musl",
+      "x86_64-pc-windows-msvc"
+    ]
+  },
+  "scripts": {
+    "build": "napi build --release --platform && npm run publish:prepare",
+    "build:debug": "napi build --platform && npm run publish:prepare",
+    "publish:prepare": "node scripts/write-dts.mjs",
+    "prepublishOnly": "npm run publish:prepare",
+    "artifacts": "napi artifacts",
+    "create-npm-dirs": "napi create-npm-dirs",
+    "test": "node test.mjs"
+  },
+  "devDependencies": {
+    "@napi-rs/cli": "3.6.0"
+  },
+  "optionalDependencies": {
+    "@fallow-cli/fallow-node-darwin-arm64": "2.47.0",
+    "@fallow-cli/fallow-node-darwin-x64": "2.47.0",
+    "@fallow-cli/fallow-node-linux-arm64-gnu": "2.47.0",
+    "@fallow-cli/fallow-node-linux-arm64-musl": "2.47.0",
+    "@fallow-cli/fallow-node-linux-x64-gnu": "2.47.0",
+    "@fallow-cli/fallow-node-linux-x64-musl": "2.47.0",
+    "@fallow-cli/fallow-node-win32-x64-msvc": "2.47.0"
+  }
+}