driftdetect-native 0.9.31

package/index.d.ts

@@ -0,0 +1,675 @@
+/* tslint:disable */
+/* eslint-disable */
+
+/* auto-generated by NAPI-RS */
+
+/** Scan result exposed to JavaScript */
+export interface JsScanResult {
+  root: string
+  files: Array<JsFileInfo>
+  stats: JsScanStats
+  errors: Array<string>
+}
+/** File info exposed to JavaScript */
+export interface JsFileInfo {
+  path: string
+  size: number
+  hash?: string
+  language?: string
+}
+/** Scan stats exposed to JavaScript */
+export interface JsScanStats {
+  totalFiles: number
+  totalBytes: number
+  dirsSkipped: number
+  filesSkipped: number
+  durationMs: number
+}
+/** Scan configuration from JavaScript */
+export interface JsScanConfig {
+  root: string
+  patterns: Array<string>
+  extraIgnores?: Array<string>
+  computeHashes?: boolean
+  maxFileSize?: number
+  threads?: number
+}
+/** Parse result exposed to JavaScript */
+export interface JsParseResult {
+  language: string
+  functions: Array<JsFunctionInfo>
+  classes: Array<JsClassInfo>
+  imports: Array<JsImportInfo>
+  exports: Array<JsExportInfo>
+  calls: Array<JsCallSite>
+  errors: Array<JsParseError>
+  parseTimeUs: number
+}
+/** Function info exposed to JavaScript */
+export interface JsFunctionInfo {
+  name: string
+  qualifiedName?: string
+  isExported: boolean
+  isAsync: boolean
+  startLine: number
+  endLine: number
+  decorators: Array<string>
+}
+/** Class info exposed to JavaScript */
+export interface JsClassInfo {
+  name: string
+  extends?: string
+  implements: Array<string>
+  isExported: boolean
+  startLine: number
+  endLine: number
+}
+/** Import info exposed to JavaScript */
+export interface JsImportInfo {
+  source: string
+  named: Array<string>
+  default?: string
+  namespace?: string
+  isTypeOnly: boolean
+  line: number
+}
+/** Export info exposed to JavaScript */
+export interface JsExportInfo {
+  name: string
+  fromSource?: string
+  isDefault: boolean
+  line: number
+}
+/** Call site exposed to JavaScript */
+export interface JsCallSite {
+  callee: string
+  receiver?: string
+  argCount: number
+  line: number
+}
+/** Parse error exposed to JavaScript */
+export interface JsParseError {
+  message: string
+  line: number
+}
+/** Scan a directory for source files */
+export declare function scan(config: JsScanConfig): JsScanResult
+/** Parse source code and extract functions, classes, imports, exports, and calls */
+export declare function parse(source: string, filePath: string): JsParseResult | null
+/** Get list of supported languages */
+export declare function supportedLanguages(): Array<string>
+/** Get the version of drift-core */
+export declare function version(): string
+/** Call graph build result exposed to JavaScript */
+export interface JsBuildResult {
+  filesProcessed: number
+  totalFunctions: number
+  totalCalls: number
+  resolvedCalls: number
+  resolutionRate: number
+  entryPoints: number
+  dataAccessors: number
+  errors: Array<string>
+  durationMs: number
+}
+/** Call graph build configuration from JavaScript */
+export interface JsBuildConfig {
+  root: string
+  patterns: Array<string>
+  resolutionBatchSize?: number
+}
+/**
+ * Build call graph for a project using SQLite storage (recommended)
+ *
+ * This uses parallel parsing with rayon and batched SQLite writes
+ * for optimal performance on large codebases.
+ */
+export declare function buildCallGraph(config: JsBuildConfig): JsBuildResult
+/**
+ * Build call graph using legacy JSON shard storage
+ *
+ * This is the original implementation, kept for backward compatibility.
+ * Use build_call_graph() for better performance.
+ */
+export declare function buildCallGraphLegacy(config: JsBuildConfig): JsBuildResult
+/** Data access point exposed to JavaScript */
+export interface JsDataAccessPoint {
+  table: string
+  operation: string
+  fields: Array<string>
+  file: string
+  line: number
+  confidence: number
+  framework?: string
+}
+/** Sensitive field exposed to JavaScript */
+export interface JsSensitiveField {
+  field: string
+  table?: string
+  sensitivityType: string
+  file: string
+  line: number
+  confidence: number
+}
+/** ORM model exposed to JavaScript */
+export interface JsOrmModel {
+  name: string
+  tableName: string
+  fields: Array<string>
+  file: string
+  line: number
+  framework: string
+  confidence: number
+}
+/** Boundary scan result exposed to JavaScript */
+export interface JsBoundaryScanResult {
+  accessPoints: Array<JsDataAccessPoint>
+  sensitiveFields: Array<JsSensitiveField>
+  models: Array<JsOrmModel>
+  filesScanned: number
+  durationMs: number
+}
+/**
+ * Scan files for data boundaries (data access points and sensitive fields)
+ * Uses AST-first approach with regex fallbacks for SQL strings
+ */
+export declare function scanBoundaries(files: Array<string>): JsBoundaryScanResult
+/** Scan a single source string for boundaries using AST-first approach */
+export declare function scanBoundariesSource(source: string, filePath: string): JsBoundaryScanResult
+/** Module metrics exposed to JavaScript */
+export interface JsModuleMetrics {
+  path: string
+  ca: number
+  ce: number
+  instability: number
+  abstractness: number
+  distance: number
+  files: Array<string>
+}
+/** Dependency cycle exposed to JavaScript */
+export interface JsDependencyCycle {
+  modules: Array<string>
+  severity: string
+  filesAffected: number
+}
+/** Coupling hotspot exposed to JavaScript */
+export interface JsCouplingHotspot {
+  module: string
+  totalCoupling: number
+  incoming: Array<string>
+  outgoing: Array<string>
+}
+/** Unused export exposed to JavaScript */
+export interface JsUnusedExport {
+  name: string
+  file: string
+  line: number
+  exportType: string
+}
+/** Coupling analysis result exposed to JavaScript */
+export interface JsCouplingResult {
+  modules: Array<JsModuleMetrics>
+  cycles: Array<JsDependencyCycle>
+  hotspots: Array<JsCouplingHotspot>
+  unusedExports: Array<JsUnusedExport>
+  healthScore: number
+  filesAnalyzed: number
+  durationMs: number
+}
+/** Analyze module coupling using AST-first approach */
+export declare function analyzeCoupling(files: Array<string>): JsCouplingResult
+/** Test file exposed to JavaScript */
+export interface JsTestFile {
+  path: string
+  testsFile?: string
+  framework: string
+  testCount: number
+  mockCount: number
+}
+/** Test coverage exposed to JavaScript */
+export interface JsTestCoverage {
+  sourceFile: string
+  testFiles: Array<string>
+  coveragePercent?: number
+  riskLevel: string
+}
+/** Test topology result exposed to JavaScript */
+export interface JsTestTopologyResult {
+  testFiles: Array<JsTestFile>
+  coverage: Array<JsTestCoverage>
+  uncoveredFiles: Array<string>
+  totalTests: number
+  skippedTests: number
+  filesAnalyzed: number
+  durationMs: number
+}
+/** Analyze test topology using AST-first approach */
+export declare function analyzeTestTopology(files: Array<string>): JsTestTopologyResult
+/** Error boundary exposed to JavaScript */
+export interface JsErrorBoundary {
+  file: string
+  startLine: number
+  endLine: number
+  boundaryType: string
+  caughtTypes: Array<string>
+  rethrows: boolean
+  logsError: boolean
+  isSwallowed: boolean
+}
+/** Error gap exposed to JavaScript */
+export interface JsErrorGap {
+  file: string
+  line: number
+  function: string
+  gapType: string
+  severity: string
+  description: string
+}
+/** Error type exposed to JavaScript */
+export interface JsErrorType {
+  name: string
+  file: string
+  line: number
+  extends?: string
+  isExported: boolean
+}
+/** Error handling result exposed to JavaScript */
+export interface JsErrorHandlingResult {
+  boundaries: Array<JsErrorBoundary>
+  gaps: Array<JsErrorGap>
+  errorTypes: Array<JsErrorType>
+  filesAnalyzed: number
+  durationMs: number
+}
+/** Analyze error handling using AST-first approach */
+export declare function analyzeErrorHandling(files: Array<string>): JsErrorHandlingResult
+/** Code location exposed to JavaScript */
+export interface JsCodeLocation {
+  file: string
+  line: number
+  column?: number
+  functionId?: string
+}
+/** Call path node exposed to JavaScript */
+export interface JsCallPathNode {
+  functionId: string
+  functionName: string
+  file: string
+  line: number
+}
+/** Reachable data access exposed to JavaScript */
+export interface JsReachableDataAccess {
+  table: string
+  operation: string
+  fields: Array<string>
+  file: string
+  line: number
+  confidence: number
+  framework?: string
+  path: Array<JsCallPathNode>
+  depth: number
+}
+/** Sensitive field access exposed to JavaScript */
+export interface JsSensitiveFieldAccess {
+  field: string
+  table?: string
+  sensitivityType: string
+  file: string
+  line: number
+  confidence: number
+  paths: Array<Array<JsCallPathNode>>
+  accessCount: number
+}
+/** Reachability result exposed to JavaScript */
+export interface JsReachabilityResult {
+  origin: JsCodeLocation
+  reachableAccess: Array<JsReachableDataAccess>
+  tables: Array<string>
+  sensitiveFields: Array<JsSensitiveFieldAccess>
+  maxDepth: number
+  functionsTraversed: number
+}
+/** Reachability options from JavaScript */
+export interface JsReachabilityOptions {
+  maxDepth?: number
+  sensitiveOnly?: boolean
+  tables?: Array<string>
+  includeUnresolved?: boolean
+}
+/** Inverse access path exposed to JavaScript */
+export interface JsInverseAccessPath {
+  entryPoint: string
+  path: Array<JsCallPathNode>
+  accessTable: string
+  accessOperation: string
+  accessFields: Array<string>
+  accessFile: string
+  accessLine: number
+}
+/** Inverse reachability result exposed to JavaScript */
+export interface JsInverseReachabilityResult {
+  targetTable: string
+  targetField?: string
+  accessPaths: Array<JsInverseAccessPath>
+  entryPoints: Array<string>
+  totalAccessors: number
+}
+/** Call graph function node from JavaScript */
+export interface JsCallGraphFunction {
+  id: string
+  name: string
+  qualifiedName: string
+  file: string
+  startLine: number
+  endLine: number
+  calls: Array<JsCallGraphCallSite>
+  dataAccess: Array<JsCallGraphDataAccess>
+  isEntryPoint: boolean
+}
+/** Call site for call graph from JavaScript */
+export interface JsCallGraphCallSite {
+  calleeName: string
+  resolved: boolean
+  resolvedCandidates: Array<string>
+  line: number
+}
+/** Data access for call graph from JavaScript */
+export interface JsCallGraphDataAccess {
+  table: string
+  operation: string
+  fields: Array<string>
+  file: string
+  line: number
+  confidence: number
+  framework?: string
+}
+/** Call graph input from JavaScript */
+export interface JsCallGraphInput {
+  functions: Array<JsCallGraphFunction>
+  entryPoints: Array<string>
+  dataAccessors: Array<string>
+}
+/** Analyze reachability from a function */
+export declare function analyzeReachability(graphInput: JsCallGraphInput, functionId: string, options: JsReachabilityOptions): JsReachabilityResult
+/** Analyze inverse reachability - who can access this data? */
+export declare function analyzeInverseReachability(graphInput: JsCallGraphInput, table: string, field?: string | undefined | null, maxDepth?: number | undefined | null): JsInverseReachabilityResult
+/**
+ * Analyze reachability from a function using SQLite storage
+ *
+ * This queries the SQLite call graph database directly, avoiding the need
+ * to load the entire call graph into memory. Recommended for large codebases.
+ *
+ * Requires: Call graph must be built first using build_call_graph()
+ */
+export declare function analyzeReachabilitySqlite(rootDir: string, functionId: string, options: JsReachabilityOptions): JsReachabilityResult
+/**
+ * Analyze inverse reachability using SQLite storage - who can access this data?
+ *
+ * This queries the SQLite call graph database directly, avoiding the need
+ * to load the entire call graph into memory. Recommended for large codebases.
+ *
+ * Requires: Call graph must be built first using build_call_graph()
+ */
+export declare function analyzeInverseReachabilitySqlite(rootDir: string, table: string, field?: string | undefined | null, maxDepth?: number | undefined | null): JsInverseReachabilityResult
+/** Check if SQLite call graph database exists and has data */
+export declare function isCallGraphAvailable(rootDir: string): boolean
+/** Call graph stats from SQLite database */
+export interface JsCallGraphStats {
+  totalFunctions: number
+  totalCalls: number
+  resolvedCalls: number
+  entryPoints: number
+  dataAccessors: number
+}
+/** Get call graph statistics from SQLite database */
+export declare function getCallGraphStats(rootDir: string): JsCallGraphStats
+/** Entry point info from SQLite database */
+export interface JsEntryPointInfo {
+  id: string
+  name: string
+  file: string
+  line: number
+}
+/** Get all entry points from SQLite call graph */
+export declare function getCallGraphEntryPoints(rootDir: string): Array<JsEntryPointInfo>
+/** Data accessor info from SQLite database */
+export interface JsDataAccessorInfo {
+  id: string
+  name: string
+  file: string
+  line: number
+  tables: Array<string>
+}
+/** Get all data accessors from SQLite call graph */
+export declare function getCallGraphDataAccessors(rootDir: string): Array<JsDataAccessorInfo>
+/** Detected pattern exposed to JavaScript */
+export interface JsDetectedPattern {
+  category: string
+  patternType: string
+  subcategory?: string
+  file: string
+  line: number
+  column: number
+  endLine: number
+  endColumn: number
+  matchedText: string
+  confidence: number
+  detectionMethod: string
+}
+/** File patterns exposed to JavaScript */
+export interface JsFilePatterns {
+  file: string
+  language: string
+  patterns: Array<JsDetectedPattern>
+  parseTimeUs: number
+  detectTimeUs: number
+}
+/** Resolution stats exposed to JavaScript */
+export interface JsResolutionStats {
+  totalCalls: number
+  resolvedCalls: number
+  resolutionRate: number
+  sameFileResolutions: number
+  crossFileResolutions: number
+  unresolvedCalls: number
+}
+/** Call graph summary exposed to JavaScript */
+export interface JsCallGraphSummary {
+  totalFunctions: number
+  entryPoints: number
+  dataAccessors: number
+  maxCallDepth: number
+}
+/** Analysis metrics exposed to JavaScript */
+export interface JsAnalysisMetrics {
+  filesProcessed: number
+  totalLines: number
+  parseTimeMs: number
+  detectTimeMs: number
+  resolveTimeMs: number
+  totalTimeMs: number
+}
+/** Unified analysis result exposed to JavaScript */
+export interface JsUnifiedResult {
+  filePatterns: Array<JsFilePatterns>
+  resolution: JsResolutionStats
+  callGraph: JsCallGraphSummary
+  metrics: JsAnalysisMetrics
+  totalPatterns: number
+  totalViolations: number
+}
+/** Unified analysis options from JavaScript */
+export interface JsUnifiedOptions {
+  patterns: Array<string>
+  categories?: Array<string>
+  maxResolutionDepth?: number
+  parallel?: boolean
+  threads?: number
+}
+/**
+ * Analyze a codebase with unified pattern detection and resolution
+ *
+ * This is the main entry point for AST-first pattern detection.
+ * Combines pattern detection and call resolution in a single pass.
+ */
+export declare function analyzeUnified(root: string, options: JsUnifiedOptions): JsUnifiedResult
+/** Constant info exposed to JavaScript */
+export interface JsConstantInfo {
+  name: string
+  value: string
+  valueType: string
+  category: string
+  file: string
+  line: number
+  isExported: boolean
+  language: string
+  declarationType: string
+}
+/** Secret candidate exposed to JavaScript */
+export interface JsSecretCandidate {
+  name: string
+  maskedValue: string
+  secretType: string
+  severity: string
+  file: string
+  line: number
+  confidence: number
+  reason: string
+}
+/** Magic number exposed to JavaScript */
+export interface JsMagicNumber {
+  value: number
+  file: string
+  line: number
+  context: string
+  suggestedName?: string
+}
+/** Value location exposed to JavaScript */
+export interface JsValueLocation {
+  value: string
+  file: string
+  line: number
+}
+/** Value inconsistency exposed to JavaScript */
+export interface JsValueInconsistency {
+  namePattern: string
+  values: Array<JsValueLocation>
+  severity: string
+}
+/** Constants stats exposed to JavaScript */
+export interface JsConstantsStats {
+  totalConstants: number
+  byCategory: Array<JsCategoryCount>
+  byLanguage: Array<JsLanguageCount>
+  exportedCount: number
+  secretsCount: number
+  magicNumbersCount: number
+  filesAnalyzed: number
+  durationMs: number
+}
+export interface JsCategoryCount {
+  category: string
+  count: number
+}
+/** Constants analysis result exposed to JavaScript */
+export interface JsConstantsResult {
+  constants: Array<JsConstantInfo>
+  secrets: Array<JsSecretCandidate>
+  magicNumbers: Array<JsMagicNumber>
+  inconsistencies: Array<JsValueInconsistency>
+  stats: JsConstantsStats
+}
+/** Analyze files for constants, secrets, and magic numbers */
+export declare function analyzeConstants(files: Array<string>): JsConstantsResult
+/** Env access exposed to JavaScript */
+export interface JsEnvAccess {
+  name: string
+  file: string
+  line: number
+  hasDefault: boolean
+  defaultValue?: string
+  accessMethod: string
+  language: string
+}
+/** Env variable exposed to JavaScript */
+export interface JsEnvVariable {
+  name: string
+  sensitivity: string
+  accesses: Array<JsEnvAccessLocation>
+  isRequired: boolean
+  defaultValues: Array<string>
+  accessCount: number
+}
+/** Env access location exposed to JavaScript */
+export interface JsEnvAccessLocation {
+  file: string
+  line: number
+  hasDefault: boolean
+}
+/** Environment stats exposed to JavaScript */
+export interface JsEnvironmentStats {
+  totalAccesses: number
+  uniqueVariables: number
+  requiredCount: number
+  secretsCount: number
+  credentialsCount: number
+  configCount: number
+  byLanguage: Array<JsLanguageCount>
+  filesAnalyzed: number
+  durationMs: number
+}
+export interface JsLanguageCount {
+  language: string
+  count: number
+}
+/** Environment analysis result exposed to JavaScript */
+export interface JsEnvironmentResult {
+  accesses: Array<JsEnvAccess>
+  variables: Array<JsEnvVariable>
+  required: Array<JsEnvVariable>
+  secrets: Array<JsEnvVariable>
+  stats: JsEnvironmentStats
+}
+/** Analyze files for environment variable usage */
+export declare function analyzeEnvironment(files: Array<string>): JsEnvironmentResult
+/** Wrapper info exposed to JavaScript */
+export interface JsWrapperInfo {
+  name: string
+  file: string
+  line: number
+  wraps: Array<string>
+  category: string
+  isExported: boolean
+  usageCount: number
+  confidence: number
+}
+/** Wrapper cluster exposed to JavaScript */
+export interface JsWrapperCluster {
+  id: string
+  category: string
+  wrappedPrimitive: string
+  wrappers: Array<JsWrapperInfo>
+  confidence: number
+  totalUsage: number
+}
+/** Wrappers stats exposed to JavaScript */
+export interface JsWrappersStats {
+  totalWrappers: number
+  clusterCount: number
+  byCategory: Array<JsCategoryCount>
+  topPrimitives: Array<JsPrimitiveCount>
+  filesAnalyzed: number
+  durationMs: number
+}
+export interface JsPrimitiveCount {
+  primitive: string
+  count: number
+}
+/** Wrappers analysis result exposed to JavaScript */
+export interface JsWrappersResult {
+  wrappers: Array<JsWrapperInfo>
+  clusters: Array<JsWrapperCluster>
+  stats: JsWrappersStats
+}
+/** Analyze files for wrapper patterns */
+export declare function analyzeWrappers(files: Array<string>): JsWrappersResult

package/index.js

@@ -0,0 +1,337 @@
+/* tslint:disable */
+/* eslint-disable */
+/* prettier-ignore */
+
+/* auto-generated by NAPI-RS */
+
+const { existsSync, readFileSync } = require('fs')
+const { join } = require('path')
+
+const { platform, arch } = process
+
+let nativeBinding = null
+let localFileExisted = false
+let loadError = null
+
+function isMusl() {
+  // For Node 10
+  if (!process.report || typeof process.report.getReport !== 'function') {
+    try {
+      const lddPath = require('child_process').execSync('which ldd').toString().trim()
+      return readFileSync(lddPath, 'utf8').includes('musl')
+    } catch (e) {
+      return true
+    }
+  } else {
+    const { glibcVersionRuntime } = process.report.getReport().header
+    return !glibcVersionRuntime
+  }
+}
+
+switch (platform) {
+  case 'android':
+    switch (arch) {
+      case 'arm64':
+        localFileExisted = existsSync(join(__dirname, 'drift-native.android-arm64.node'))
+        try {
+          if (localFileExisted) {
+            nativeBinding = require('./drift-native.android-arm64.node')
+          } else {
+            nativeBinding = require('driftdetect-native-android-arm64')
+          }
+        } catch (e) {
+          loadError = e
+        }
+        break
+      case 'arm':
+        localFileExisted = existsSync(join(__dirname, 'drift-native.android-arm-eabi.node'))
+        try {
+          if (localFileExisted) {
+            nativeBinding = require('./drift-native.android-arm-eabi.node')
+          } else {
+            nativeBinding = require('driftdetect-native-android-arm-eabi')
+          }
+        } catch (e) {
+          loadError = e
+        }
+        break
+      default:
+        throw new Error(`Unsupported architecture on Android ${arch}`)
+    }
+    break
+  case 'win32':
+    switch (arch) {
+      case 'x64':
+        localFileExisted = existsSync(
+          join(__dirname, 'drift-native.win32-x64-msvc.node')
+        )
+        try {
+          if (localFileExisted) {
+            nativeBinding = require('./drift-native.win32-x64-msvc.node')
+          } else {
+            nativeBinding = require('driftdetect-native-win32-x64-msvc')
+          }
+        } catch (e) {
+          loadError = e
+        }
+        break
+      case 'ia32':
+        localFileExisted = existsSync(
+          join(__dirname, 'drift-native.win32-ia32-msvc.node')
+        )
+        try {
+          if (localFileExisted) {
+            nativeBinding = require('./drift-native.win32-ia32-msvc.node')
+          } else {
+            nativeBinding = require('driftdetect-native-win32-ia32-msvc')
+          }
+        } catch (e) {
+          loadError = e
+        }
+        break
+      case 'arm64':
+        localFileExisted = existsSync(
+          join(__dirname, 'drift-native.win32-arm64-msvc.node')
+        )
+        try {
+          if (localFileExisted) {
+            nativeBinding = require('./drift-native.win32-arm64-msvc.node')
+          } else {
+            nativeBinding = require('driftdetect-native-win32-arm64-msvc')
+          }
+        } catch (e) {
+          loadError = e
+        }
+        break
+      default:
+        throw new Error(`Unsupported architecture on Windows: ${arch}`)
+    }
+    break
+  case 'darwin':
+    localFileExisted = existsSync(join(__dirname, 'drift-native.darwin-universal.node'))
+    try {
+      if (localFileExisted) {
+        nativeBinding = require('./drift-native.darwin-universal.node')
+      } else {
+        nativeBinding = require('driftdetect-native-darwin-universal')
+      }
+      break
+    } catch {}
+    switch (arch) {
+      case 'x64':
+        localFileExisted = existsSync(join(__dirname, 'drift-native.darwin-x64.node'))
+        try {
+          if (localFileExisted) {
+            nativeBinding = require('./drift-native.darwin-x64.node')
+          } else {
+            nativeBinding = require('driftdetect-native-darwin-x64')
+          }
+        } catch (e) {
+          loadError = e
+        }
+        break
+      case 'arm64':
+        localFileExisted = existsSync(
+          join(__dirname, 'drift-native.darwin-arm64.node')
+        )
+        try {
+          if (localFileExisted) {
+            nativeBinding = require('./drift-native.darwin-arm64.node')
+          } else {
+            nativeBinding = require('driftdetect-native-darwin-arm64')
+          }
+        } catch (e) {
+          loadError = e
+        }
+        break
+      default:
+        throw new Error(`Unsupported architecture on macOS: ${arch}`)
+    }
+    break
+  case 'freebsd':
+    if (arch !== 'x64') {
+      throw new Error(`Unsupported architecture on FreeBSD: ${arch}`)
+    }
+    localFileExisted = existsSync(join(__dirname, 'drift-native.freebsd-x64.node'))
+    try {
+      if (localFileExisted) {
+        nativeBinding = require('./drift-native.freebsd-x64.node')
+      } else {
+        nativeBinding = require('driftdetect-native-freebsd-x64')
+      }
+    } catch (e) {
+      loadError = e
+    }
+    break
+  case 'linux':
+    switch (arch) {
+      case 'x64':
+        if (isMusl()) {
+          localFileExisted = existsSync(
+            join(__dirname, 'drift-native.linux-x64-musl.node')
+          )
+          try {
+            if (localFileExisted) {
+              nativeBinding = require('./drift-native.linux-x64-musl.node')
+            } else {
+              nativeBinding = require('driftdetect-native-linux-x64-musl')
+            }
+          } catch (e) {
+            loadError = e
+          }
+        } else {
+          localFileExisted = existsSync(
+            join(__dirname, 'drift-native.linux-x64-gnu.node')
+          )
+          try {
+            if (localFileExisted) {
+              nativeBinding = require('./drift-native.linux-x64-gnu.node')
+            } else {
+              nativeBinding = require('driftdetect-native-linux-x64-gnu')
+            }
+          } catch (e) {
+            loadError = e
+          }
+        }
+        break
+      case 'arm64':
+        if (isMusl()) {
+          localFileExisted = existsSync(
+            join(__dirname, 'drift-native.linux-arm64-musl.node')
+          )
+          try {
+            if (localFileExisted) {
+              nativeBinding = require('./drift-native.linux-arm64-musl.node')
+            } else {
+              nativeBinding = require('driftdetect-native-linux-arm64-musl')
+            }
+          } catch (e) {
+            loadError = e
+          }
+        } else {
+          localFileExisted = existsSync(
+            join(__dirname, 'drift-native.linux-arm64-gnu.node')
+          )
+          try {
+            if (localFileExisted) {
+              nativeBinding = require('./drift-native.linux-arm64-gnu.node')
+            } else {
+              nativeBinding = require('driftdetect-native-linux-arm64-gnu')
+            }
+          } catch (e) {
+            loadError = e
+          }
+        }
+        break
+      case 'arm':
+        if (isMusl()) {
+          localFileExisted = existsSync(
+            join(__dirname, 'drift-native.linux-arm-musleabihf.node')
+          )
+          try {
+            if (localFileExisted) {
+              nativeBinding = require('./drift-native.linux-arm-musleabihf.node')
+            } else {
+              nativeBinding = require('driftdetect-native-linux-arm-musleabihf')
+            }
+          } catch (e) {
+            loadError = e
+          }
+        } else {
+          localFileExisted = existsSync(
+            join(__dirname, 'drift-native.linux-arm-gnueabihf.node')
+          )
+          try {
+            if (localFileExisted) {
+              nativeBinding = require('./drift-native.linux-arm-gnueabihf.node')
+            } else {
+              nativeBinding = require('driftdetect-native-linux-arm-gnueabihf')
+            }
+          } catch (e) {
+            loadError = e
+          }
+        }
+        break
+      case 'riscv64':
+        if (isMusl()) {
+          localFileExisted = existsSync(
+            join(__dirname, 'drift-native.linux-riscv64-musl.node')
+          )
+          try {
+            if (localFileExisted) {
+              nativeBinding = require('./drift-native.linux-riscv64-musl.node')
+            } else {
+              nativeBinding = require('driftdetect-native-linux-riscv64-musl')
+            }
+          } catch (e) {
+            loadError = e
+          }
+        } else {
+          localFileExisted = existsSync(
+            join(__dirname, 'drift-native.linux-riscv64-gnu.node')
+          )
+          try {
+            if (localFileExisted) {
+              nativeBinding = require('./drift-native.linux-riscv64-gnu.node')
+            } else {
+              nativeBinding = require('driftdetect-native-linux-riscv64-gnu')
+            }
+          } catch (e) {
+            loadError = e
+          }
+        }
+        break
+      case 's390x':
+        localFileExisted = existsSync(
+          join(__dirname, 'drift-native.linux-s390x-gnu.node')
+        )
+        try {
+          if (localFileExisted) {
+            nativeBinding = require('./drift-native.linux-s390x-gnu.node')
+          } else {
+            nativeBinding = require('driftdetect-native-linux-s390x-gnu')
+          }
+        } catch (e) {
+          loadError = e
+        }
+        break
+      default:
+        throw new Error(`Unsupported architecture on Linux: ${arch}`)
+    }
+    break
+  default:
+    throw new Error(`Unsupported OS: ${platform}, architecture: ${arch}`)
+}
+
+if (!nativeBinding) {
+  if (loadError) {
+    throw loadError
+  }
+  throw new Error(`Failed to load native binding`)
+}
+
+const { scan, parse, supportedLanguages, version, buildCallGraph, buildCallGraphLegacy, scanBoundaries, scanBoundariesSource, analyzeCoupling, analyzeTestTopology, analyzeErrorHandling, analyzeReachability, analyzeInverseReachability, analyzeReachabilitySqlite, analyzeInverseReachabilitySqlite, isCallGraphAvailable, getCallGraphStats, getCallGraphEntryPoints, getCallGraphDataAccessors, analyzeUnified, analyzeConstants, analyzeEnvironment, analyzeWrappers } = nativeBinding
+
+module.exports.scan = scan
+module.exports.parse = parse
+module.exports.supportedLanguages = supportedLanguages
+module.exports.version = version
+module.exports.buildCallGraph = buildCallGraph
+module.exports.buildCallGraphLegacy = buildCallGraphLegacy
+module.exports.scanBoundaries = scanBoundaries
+module.exports.scanBoundariesSource = scanBoundariesSource
+module.exports.analyzeCoupling = analyzeCoupling
+module.exports.analyzeTestTopology = analyzeTestTopology
+module.exports.analyzeErrorHandling = analyzeErrorHandling
+module.exports.analyzeReachability = analyzeReachability
+module.exports.analyzeInverseReachability = analyzeInverseReachability
+module.exports.analyzeReachabilitySqlite = analyzeReachabilitySqlite
+module.exports.analyzeInverseReachabilitySqlite = analyzeInverseReachabilitySqlite
+module.exports.isCallGraphAvailable = isCallGraphAvailable
+module.exports.getCallGraphStats = getCallGraphStats
+module.exports.getCallGraphEntryPoints = getCallGraphEntryPoints
+module.exports.getCallGraphDataAccessors = getCallGraphDataAccessors
+module.exports.analyzeUnified = analyzeUnified
+module.exports.analyzeConstants = analyzeConstants
+module.exports.analyzeEnvironment = analyzeEnvironment
+module.exports.analyzeWrappers = analyzeWrappers

package/package.json

@@ -0,0 +1,61 @@
+{
+  "name": "driftdetect-native",
+  "version": "0.9.31",
+  "description": "Native Rust core for Drift - high-performance code analysis",
+  "main": "index.js",
+  "types": "index.d.ts",
+  "napi": {
+    "name": "drift-native",
+    "triples": {
+      "defaults": true,
+      "additional": [
+        "aarch64-apple-darwin",
+        "aarch64-unknown-linux-gnu",
+        "aarch64-unknown-linux-musl",
+        "x86_64-unknown-linux-musl"
+      ]
+    }
+  },
+  "files": [
+    "index.js",
+    "index.d.ts",
+    "*.node"
+  ],
+  "engines": {
+    "node": ">= 18"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/AgenDrift/drift.git",
+    "directory": "crates/drift-napi"
+  },
+  "keywords": [
+    "drift",
+    "code-analysis",
+    "ast",
+    "parser",
+    "call-graph",
+    "rust",
+    "napi"
+  ],
+  "license": "MIT",
+  "devDependencies": {
+    "@napi-rs/cli": "^2.18.0"
+  },
+  "scripts": {
+    "build": "napi build --platform --release",
+    "build:debug": "napi build --platform",
+    "prepublishOnly": "napi prepublish -t npm",
+    "artifacts": "napi artifacts",
+    "version": "napi version"
+  },
+  "optionalDependencies": {
+    "driftdetect-native-win32-x64-msvc": "0.9.31",
+    "driftdetect-native-darwin-x64": "0.9.31",
+    "driftdetect-native-linux-x64-gnu": "0.9.31",
+    "driftdetect-native-darwin-arm64": "0.9.31",
+    "driftdetect-native-linux-arm64-gnu": "0.9.31",
+    "driftdetect-native-linux-arm64-musl": "0.9.31",
+    "driftdetect-native-linux-x64-musl": "0.9.31"
+  }
+}