infiniloom-node 0.1.0

package/README.md

@@ -0,0 +1,293 @@
+# @infiniloom/node
+
+Node.js bindings for Infiniloom - Repository context engine for LLMs.
+
+## Features
+
+- **Pack repositories** into optimized LLM context with configurable compression
+- **Scan repositories** for statistics and metadata
+- **Count tokens** for different LLM models
+- **Security scanning** to detect secrets and sensitive data
+- **Fast native performance** powered by Rust and NAPI-RS
+- **Cross-platform** support (macOS, Linux, Windows)
+
+## Installation
+
+Phase 2 (not implemented intentionally): `npm install @infiniloom/node` (npm release).
+For now, build from source in this repository.
+
+## Quick Start
+
+### Simple Packing
+
+```javascript
+const { pack } = require('@infiniloom/node');
+
+// Pack a repository with default settings
+const context = pack('./my-repo');
+console.log(context);
+```
+
+### With Options
+
+```javascript
+const { pack } = require('@infiniloom/node');
+
+const context = pack('./my-repo', {
+  format: 'xml',           // Output format: 'xml', 'markdown', 'json', or 'yaml'
+  model: 'claude',         // Target model: 'claude', 'gpt-5.2', 'o3', 'gpt-4o', 'gemini', 'llama', etc.
+  compression: 'balanced', // Compression: 'none', 'minimal', 'balanced', 'aggressive', 'extreme'
+  mapBudget: 2000,        // Token budget for repository map
+  maxSymbols: 50,         // Maximum symbols to include in map
+  skipSecurity: false,    // Skip security scanning
+  redactSecrets: true,    // Redact detected secrets in output (default true)
+  skipSymbols: false      // Skip symbol extraction for faster scans
+});
+```
+
+### Repository Scanning
+
+```javascript
+const { scan } = require('@infiniloom/node');
+
+const stats = scan('./my-repo', 'claude');
+console.log(`Repository: ${stats.name}`);
+console.log(`Total files: ${stats.totalFiles}`);
+console.log(`Total lines: ${stats.totalLines}`);
+console.log(`Total tokens: ${stats.totalTokens}`);
+console.log(`Primary language: ${stats.primaryLanguage}`);
+console.log(`Languages:`, stats.languages);
+```
+
+### Token Counting
+
+```javascript
+const { countTokens } = require('@infiniloom/node');
+
+const count = countTokens('Hello, world!', 'claude');
+console.log(`Tokens: ${count}`);
+```
+
+### Semantic Compression
+
+```javascript
+const { semanticCompress } = require('@infiniloom/node');
+
+// Compress text while preserving important content
+const longText = '... your long text content ...';
+const compressed = semanticCompress(longText, 0.7, 0.5);
+// Parameters:
+//   - text: The text to compress
+//   - similarityThreshold (optional): 0.0-1.0, default 0.7
+//   - budgetRatio (optional): 0.0-1.0, default 0.5
+console.log(compressed);
+```
+
+### Advanced Usage with Infiniloom Class
+
+```javascript
+const { Infiniloom } = require('@infiniloom/node');
+
+// Create an Infiniloom instance
+const loom = new Infiniloom('./my-repo', 'claude');
+
+// Get statistics
+const stats = loom.getStats();
+console.log(stats);
+
+// Generate repository map
+const map = loom.generateMap(2000, 50);
+console.log(map);
+
+// Pack with options
+const context = loom.pack({
+  format: 'xml',
+  compression: 'balanced'
+});
+console.log(context);
+
+// Security scan
+const findings = loom.securityScan();
+if (findings.length > 0) {
+  console.warn('Security issues found:');
+  findings.forEach(finding => console.warn(finding));
+}
+```
+
+## API Reference
+
+### Functions
+
+#### `pack(path: string, options?: PackOptions): string`
+
+Pack a repository into optimized LLM context.
+
+**Parameters:**
+- `path` - Path to repository root
+- `options` - Optional packing options
+
+**Returns:** Formatted repository context as a string
+
+#### `scan(path: string, model?: string): ScanStats`
+
+Scan a repository and return statistics.
+
+**Parameters:**
+- `path` - Path to repository root
+- `model` - Optional target model (default: "claude")
+
+**Returns:** Repository statistics
+
+#### `countTokens(text: string, model?: string): number`
+
+Count tokens in text for a specific model.
+
+**Parameters:**
+- `text` - Text to tokenize
+- `model` - Optional model name (default: "claude")
+
+**Returns:** Token count
+
+#### `semanticCompress(text: string, similarityThreshold?: number, budgetRatio?: number): string`
+
+Compress text using semantic compression while preserving important content.
+
+**Parameters:**
+- `text` - Text to compress
+- `similarityThreshold` - Threshold for grouping similar chunks (0.0-1.0, default: 0.7)
+- `budgetRatio` - Target size as ratio of original (0.0-1.0, default: 0.5)
+
+**Returns:** Compressed text
+
+### Types
+
+#### `PackOptions`
+
+```typescript
+interface PackOptions {
+  format?: string;        // "xml", "markdown", "json", "yaml", "toon", or "plain"
+  model?: string;         // "claude", "gpt-4o", "gpt-4", "gemini", "llama", etc.
+  compression?: string;   // "none", "minimal", "balanced", "aggressive", "extreme", "focused", "semantic"
+  mapBudget?: number;     // Token budget for repository map
+  maxSymbols?: number;    // Maximum number of symbols in map
+  skipSecurity?: boolean; // Skip security scanning
+  redactSecrets?: boolean;// Redact detected secrets
+  skipSymbols?: boolean;  // Skip symbol extraction
+}
+```
+
+#### `ScanStats`
+
+```typescript
+interface ScanStats {
+  name: string;
+  totalFiles: number;
+  totalLines: number;
+  totalTokens: number;
+  primaryLanguage?: string;
+  languages: LanguageStat[];
+  securityFindings: number;
+}
+```
+
+#### `LanguageStat`
+
+```typescript
+interface LanguageStat {
+  language: string;
+  files: number;
+  lines: number;
+  percentage: number;
+}
+```
+
+### Infiniloom Class
+
+#### `new Infiniloom(path: string, model?: string)`
+
+Create a new Infiniloom instance.
+
+#### `getStats(): ScanStats`
+
+Get repository statistics.
+
+#### `generateMap(budget?: number, maxSymbols?: number): string`
+
+Generate a repository map.
+
+#### `pack(options?: PackOptions): string`
+
+Pack repository with specific options.
+
+#### `securityScan(): string[]`
+
+Check for security issues and return findings.
+
+## Supported Models
+
+- **Claude** - Anthropic's Claude models
+- **GPT-4o** - OpenAI's GPT-4o
+- **GPT-4** - OpenAI's GPT-4
+- **Gemini** - Google's Gemini
+- **Llama** - Meta's Llama
+
+## Compression Levels
+
+- **none** - No compression (0% reduction)
+- **minimal** - Remove empty lines, trim whitespace (~15% reduction)
+- **balanced** - Remove comments, normalize whitespace (~35% reduction)
+- **aggressive** - Remove docstrings, keep signatures only (~60% reduction)
+- **extreme** - Key symbols only (~80% reduction)
+- **focused** - Key symbols with small context (~75% reduction)
+- **semantic** - Heuristic semantic compression (~60-70% reduction)
+
+## Output Formats
+
+- **xml** - XML format optimized for Claude
+- **markdown** - Markdown format for GPT models
+- **json** - JSON format for programmatic access
+- **yaml** - YAML format optimized for Gemini
+- **toon** - Token-efficient format (~40% smaller than JSON)
+- **plain** - Simple plain text format
+
+## Security Scanning
+
+Infiniloom automatically scans for sensitive data including:
+
+- API keys
+- Access tokens
+- Private keys
+- Passwords
+- Database connection strings
+- AWS credentials
+- GitHub tokens
+
+Critical security issues will prevent packing unless `skipSecurity: true` is set.
+
+## Building from Source
+
+```bash
+# Install dependencies
+npm install
+
+# Build native addon
+npm run build
+
+# Build for release
+npm run build --release
+```
+
+## Requirements
+
+- Node.js >= 16
+- Rust >= 1.91 (for building from source)
+
+## License
+
+MIT
+
+## Links
+
+- [GitHub Repository](https://github.com/Topos-Labs/infiniloom)
+- [Documentation](https://infiniloom.dev/docs)
+- [npm Package](https://www.npmjs.com/package/@infiniloom/node)

package/index.d.ts

@@ -0,0 +1,396 @@
+/* tslint:disable */
+/* eslint-disable */
+
+/* auto-generated by NAPI-RS */
+
+/** Options for packing a repository */
+export interface PackOptions {
+  /** Output format: "xml", "markdown", "json", or "yaml" */
+  format?: string
+  /** Target model: "claude", "gpt-4o", "gpt-4", "gemini", or "llama" */
+  model?: string
+  /** Compression level: "none", "minimal", "balanced", "aggressive", "extreme", "focused", "semantic" */
+  compression?: string
+  /** Token budget for repository map */
+  mapBudget?: number
+  /** Maximum number of symbols in map */
+  maxSymbols?: number
+  /** Skip security scanning (fail on critical findings) */
+  skipSecurity?: boolean
+  /** Redact detected secrets in output (default: true) */
+  redactSecrets?: boolean
+  /** Skip symbol extraction for faster scanning */
+  skipSymbols?: boolean
+}
+/** Statistics from scanning a repository */
+export interface ScanStats {
+  /** Repository name */
+  name: string
+  /** Total number of files */
+  totalFiles: number
+  /** Total lines of code */
+  totalLines: number
+  /** Total tokens for target model */
+  totalTokens: number
+  /** Primary language */
+  primaryLanguage?: string
+  /** Language breakdown */
+  languages: Array<LanguageStat>
+  /** Number of security findings */
+  securityFindings: number
+}
+/** Statistics for a single language */
+export interface LanguageStat {
+  /** Language name */
+  language: string
+  /** Number of files */
+  files: number
+  /** Total lines */
+  lines: number
+  /** Percentage of codebase */
+  percentage: number
+}
+/**
+ * Pack a repository into optimized LLM context
+ *
+ * # Arguments
+ * * `path` - Path to repository root
+ * * `options` - Optional packing options
+ *
+ * # Returns
+ * Formatted repository context as a string
+ *
+ * # Example
+ * ```javascript
+ * const { pack } = require('@infiniloom/node');
+ *
+ * const context = pack('./my-repo', {
+ *   format: 'xml',
+ *   model: 'claude',
+ *   compression: 'balanced',
+ *   mapBudget: 2000
+ * });
+ * ```
+ */
+export declare function pack(path: string, options?: PackOptions | undefined | null): string
+/**
+ * Scan a repository and return statistics
+ *
+ * # Arguments
+ * * `path` - Path to repository root
+ * * `model` - Optional target model (default: "claude")
+ *
+ * # Returns
+ * Repository statistics
+ *
+ * # Example
+ * ```javascript
+ * const { scan } = require('@infiniloom/node');
+ *
+ * const stats = scan('./my-repo', 'claude');
+ * console.log(`Total files: ${stats.totalFiles}`);
+ * console.log(`Total tokens: ${stats.totalTokens}`);
+ * ```
+ */
+export declare function scan(path: string, model?: string | undefined | null): ScanStats
+/**
+ * Count tokens in text for a specific model
+ *
+ * # Arguments
+ * * `text` - Text to tokenize
+ * * `model` - Optional model name (default: "claude")
+ *
+ * # Returns
+ * Token count (exact for OpenAI models via tiktoken, calibrated estimates for others)
+ *
+ * # Example
+ * ```javascript
+ * const { countTokens } = require('@infiniloom/node');
+ *
+ * const count = countTokens('Hello, world!', 'claude');
+ * console.log(`Tokens: ${count}`);
+ * ```
+ */
+export declare function countTokens(text: string, model?: string | undefined | null): number
+/**
+ * Compress text using semantic compression
+ *
+ * Uses heuristic-based compression to reduce content while preserving meaning.
+ * When built with the "embeddings" feature, uses neural networks for clustering.
+ *
+ * # Arguments
+ * * `text` - Text to compress
+ * * `similarity_threshold` - Threshold for grouping similar chunks (0.0-1.0, default: 0.7)
+ * * `budget_ratio` - Target size as ratio of original (0.0-1.0, default: 0.5)
+ *
+ * # Returns
+ * Compressed text
+ *
+ * # Example
+ * ```javascript
+ * const { semanticCompress } = require('@infiniloom/node');
+ *
+ * const compressed = semanticCompress(longText, 0.7, 0.3);
+ * ```
+ */
+export declare function semanticCompress(text: string, similarityThreshold?: number | undefined | null, budgetRatio?: number | undefined | null): string
+/**
+ * Check if a path is a git repository
+ *
+ * # Arguments
+ * * `path` - Path to check
+ *
+ * # Returns
+ * True if path is a git repository, false otherwise
+ *
+ * # Example
+ * ```javascript
+ * const { isGitRepo } = require('@infiniloom/node');
+ *
+ * if (isGitRepo('./my-project')) {
+ *   console.log('This is a git repository');
+ * }
+ * ```
+ */
+export declare function isGitRepo(path: string): boolean
+/** File status information */
+export interface GitFileStatus {
+  /** File path */
+  path: string
+  /** Old path (for renames) */
+  oldPath?: string
+  /** Status: "Added", "Modified", "Deleted", "Renamed", "Copied", "Unknown" */
+  status: string
+}
+/** Changed file with diff stats */
+export interface GitChangedFile {
+  /** File path */
+  path: string
+  /** Old path (for renames) */
+  oldPath?: string
+  /** Status: "Added", "Modified", "Deleted", "Renamed", "Copied", "Unknown" */
+  status: string
+  /** Number of lines added */
+  additions: number
+  /** Number of lines deleted */
+  deletions: number
+}
+/** Commit information */
+export interface GitCommit {
+  /** Full commit hash */
+  hash: string
+  /** Short commit hash (7 characters) */
+  shortHash: string
+  /** Author name */
+  author: string
+  /** Author email */
+  email: string
+  /** Commit date (ISO 8601 format) */
+  date: string
+  /** Commit message (first line) */
+  message: string
+}
+/** Blame line information */
+export interface GitBlameLine {
+  /** Commit hash that introduced the line */
+  commit: string
+  /** Author who wrote the line */
+  author: string
+  /** Date when line was written */
+  date: string
+  /** Line number (1-indexed) */
+  lineNumber: number
+}
+/** Infiniloom class for advanced usage */
+export declare class Infiniloom {
+  /**
+   * Create a new Infiniloom instance
+   *
+   * # Arguments
+   * * `path` - Path to repository root
+   * * `model` - Optional model name (default: "claude")
+   */
+  constructor(path: string, model?: string | undefined | null)
+  /** Get repository statistics */
+  getStats(): ScanStats
+  /**
+   * Generate a repository map
+   *
+   * # Arguments
+   * * `budget` - Token budget (default: 2000)
+   * * `max_symbols` - Maximum symbols (default: 50)
+   */
+  generateMap(budget?: number | undefined | null, maxSymbols?: number | undefined | null): string
+  /** Pack repository with specific options */
+  pack(options?: PackOptions | undefined | null): string
+  /** Check for security issues */
+  securityScan(): Array<string>
+}
+/**
+ * Git repository wrapper for Node.js
+ *
+ * Provides access to git operations like status, diff, log, and blame.
+ *
+ * # Example
+ * ```javascript
+ * const { GitRepo } = require('@infiniloom/node');
+ *
+ * const repo = new GitRepo('./my-project');
+ * console.log(`Branch: ${repo.currentBranch()}`);
+ * console.log(`Commit: ${repo.currentCommit()}`);
+ *
+ * for (const file of repo.status()) {
+ *   console.log(`${file.status}: ${file.path}`);
+ * }
+ * ```
+ */
+export declare class GitRepo {
+  /**
+   * Open a git repository
+   *
+   * # Arguments
+   * * `path` - Path to the repository
+   *
+   * # Throws
+   * Error if path is not a git repository
+   */
+  constructor(path: string)
+  /**
+   * Get the current branch name
+   *
+   * # Returns
+   * Current branch name (e.g., "main", "feature/xyz")
+   */
+  currentBranch(): string
+  /**
+   * Get the current commit hash
+   *
+   * # Returns
+   * Full SHA-1 hash of HEAD commit
+   */
+  currentCommit(): string
+  /**
+   * Get working tree status
+   *
+   * Returns both staged and unstaged changes.
+   *
+   * # Returns
+   * Array of file status objects
+   */
+  status(): Array<GitFileStatus>
+  /**
+   * Get files changed between two commits
+   *
+   * # Arguments
+   * * `from_ref` - Starting commit/branch/tag
+   * * `to_ref` - Ending commit/branch/tag
+   *
+   * # Returns
+   * Array of changed files with diff stats
+   */
+  diffFiles(fromRef: string, toRef: string): Array<GitChangedFile>
+  /**
+   * Get recent commits
+   *
+   * # Arguments
+   * * `count` - Maximum number of commits to return (default: 10)
+   *
+   * # Returns
+   * Array of commit objects
+   */
+  log(count?: number | undefined | null): Array<GitCommit>
+  /**
+   * Get commits that modified a specific file
+   *
+   * # Arguments
+   * * `path` - File path (relative to repo root)
+   * * `count` - Maximum number of commits to return (default: 10)
+   *
+   * # Returns
+   * Array of commits that modified the file
+   */
+  fileLog(path: string, count?: number | undefined | null): Array<GitCommit>
+  /**
+   * Get blame information for a file
+   *
+   * # Arguments
+   * * `path` - File path (relative to repo root)
+   *
+   * # Returns
+   * Array of blame line objects
+   */
+  blame(path: string): Array<GitBlameLine>
+  /**
+   * Get list of files tracked by git
+   *
+   * # Returns
+   * Array of file paths tracked by git
+   */
+  lsFiles(): Array<string>
+  /**
+   * Get diff content between two commits for a file
+   *
+   * # Arguments
+   * * `from_ref` - Starting commit/branch/tag
+   * * `to_ref` - Ending commit/branch/tag
+   * * `path` - File path (relative to repo root)
+   *
+   * # Returns
+   * Unified diff content as string
+   */
+  diffContent(fromRef: string, toRef: string, path: string): string
+  /**
+   * Get diff content for uncommitted changes in a file
+   *
+   * Includes both staged and unstaged changes compared to HEAD.
+   *
+   * # Arguments
+   * * `path` - File path (relative to repo root)
+   *
+   * # Returns
+   * Unified diff content as string
+   */
+  uncommittedDiff(path: string): string
+  /**
+   * Get diff for all uncommitted changes
+   *
+   * Returns combined diff for all changed files.
+   *
+   * # Returns
+   * Unified diff content as string
+   */
+  allUncommittedDiffs(): string
+  /**
+   * Check if a file has uncommitted changes
+   *
+   * # Arguments
+   * * `path` - File path (relative to repo root)
+   *
+   * # Returns
+   * True if file has changes, false otherwise
+   */
+  hasChanges(path: string): boolean
+  /**
+   * Get the last commit that modified a file
+   *
+   * # Arguments
+   * * `path` - File path (relative to repo root)
+   *
+   * # Returns
+   * Commit information object
+   */
+  lastModifiedCommit(path: string): GitCommit
+  /**
+   * Get file change frequency in recent days
+   *
+   * Useful for determining file importance based on recent activity.
+   *
+   * # Arguments
+   * * `path` - File path (relative to repo root)
+   * * `days` - Number of days to look back (default: 30)
+   *
+   * # Returns
+   * Number of commits that modified the file in the period
+   */
+  fileChangeFrequency(path: string, days?: number | undefined | null): number
+}

package/index.js

@@ -0,0 +1,321 @@
+/* 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, 'infiniloom.android-arm64.node'))
+        try {
+          if (localFileExisted) {
+            nativeBinding = require('./infiniloom.android-arm64.node')
+          } else {
+            nativeBinding = require('@infiniloom/node-android-arm64')
+          }
+        } catch (e) {
+          loadError = e
+        }
+        break
+      case 'arm':
+        localFileExisted = existsSync(join(__dirname, 'infiniloom.android-arm-eabi.node'))
+        try {
+          if (localFileExisted) {
+            nativeBinding = require('./infiniloom.android-arm-eabi.node')
+          } else {
+            nativeBinding = require('@infiniloom/node-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, 'infiniloom.win32-x64-msvc.node')
+        )
+        try {
+          if (localFileExisted) {
+            nativeBinding = require('./infiniloom.win32-x64-msvc.node')
+          } else {
+            nativeBinding = require('@infiniloom/node-win32-x64-msvc')
+          }
+        } catch (e) {
+          loadError = e
+        }
+        break
+      case 'ia32':
+        localFileExisted = existsSync(
+          join(__dirname, 'infiniloom.win32-ia32-msvc.node')
+        )
+        try {
+          if (localFileExisted) {
+            nativeBinding = require('./infiniloom.win32-ia32-msvc.node')
+          } else {
+            nativeBinding = require('@infiniloom/node-win32-ia32-msvc')
+          }
+        } catch (e) {
+          loadError = e
+        }
+        break
+      case 'arm64':
+        localFileExisted = existsSync(
+          join(__dirname, 'infiniloom.win32-arm64-msvc.node')
+        )
+        try {
+          if (localFileExisted) {
+            nativeBinding = require('./infiniloom.win32-arm64-msvc.node')
+          } else {
+            nativeBinding = require('@infiniloom/node-win32-arm64-msvc')
+          }
+        } catch (e) {
+          loadError = e
+        }
+        break
+      default:
+        throw new Error(`Unsupported architecture on Windows: ${arch}`)
+    }
+    break
+  case 'darwin':
+    localFileExisted = existsSync(join(__dirname, 'infiniloom.darwin-universal.node'))
+    try {
+      if (localFileExisted) {
+        nativeBinding = require('./infiniloom.darwin-universal.node')
+      } else {
+        nativeBinding = require('@infiniloom/node-darwin-universal')
+      }
+      break
+    } catch {}
+    switch (arch) {
+      case 'x64':
+        localFileExisted = existsSync(join(__dirname, 'infiniloom.darwin-x64.node'))
+        try {
+          if (localFileExisted) {
+            nativeBinding = require('./infiniloom.darwin-x64.node')
+          } else {
+            nativeBinding = require('@infiniloom/node-darwin-x64')
+          }
+        } catch (e) {
+          loadError = e
+        }
+        break
+      case 'arm64':
+        localFileExisted = existsSync(
+          join(__dirname, 'infiniloom.darwin-arm64.node')
+        )
+        try {
+          if (localFileExisted) {
+            nativeBinding = require('./infiniloom.darwin-arm64.node')
+          } else {
+            nativeBinding = require('@infiniloom/node-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, 'infiniloom.freebsd-x64.node'))
+    try {
+      if (localFileExisted) {
+        nativeBinding = require('./infiniloom.freebsd-x64.node')
+      } else {
+        nativeBinding = require('@infiniloom/node-freebsd-x64')
+      }
+    } catch (e) {
+      loadError = e
+    }
+    break
+  case 'linux':
+    switch (arch) {
+      case 'x64':
+        if (isMusl()) {
+          localFileExisted = existsSync(
+            join(__dirname, 'infiniloom.linux-x64-musl.node')
+          )
+          try {
+            if (localFileExisted) {
+              nativeBinding = require('./infiniloom.linux-x64-musl.node')
+            } else {
+              nativeBinding = require('@infiniloom/node-linux-x64-musl')
+            }
+          } catch (e) {
+            loadError = e
+          }
+        } else {
+          localFileExisted = existsSync(
+            join(__dirname, 'infiniloom.linux-x64-gnu.node')
+          )
+          try {
+            if (localFileExisted) {
+              nativeBinding = require('./infiniloom.linux-x64-gnu.node')
+            } else {
+              nativeBinding = require('@infiniloom/node-linux-x64-gnu')
+            }
+          } catch (e) {
+            loadError = e
+          }
+        }
+        break
+      case 'arm64':
+        if (isMusl()) {
+          localFileExisted = existsSync(
+            join(__dirname, 'infiniloom.linux-arm64-musl.node')
+          )
+          try {
+            if (localFileExisted) {
+              nativeBinding = require('./infiniloom.linux-arm64-musl.node')
+            } else {
+              nativeBinding = require('@infiniloom/node-linux-arm64-musl')
+            }
+          } catch (e) {
+            loadError = e
+          }
+        } else {
+          localFileExisted = existsSync(
+            join(__dirname, 'infiniloom.linux-arm64-gnu.node')
+          )
+          try {
+            if (localFileExisted) {
+              nativeBinding = require('./infiniloom.linux-arm64-gnu.node')
+            } else {
+              nativeBinding = require('@infiniloom/node-linux-arm64-gnu')
+            }
+          } catch (e) {
+            loadError = e
+          }
+        }
+        break
+      case 'arm':
+        if (isMusl()) {
+          localFileExisted = existsSync(
+            join(__dirname, 'infiniloom.linux-arm-musleabihf.node')
+          )
+          try {
+            if (localFileExisted) {
+              nativeBinding = require('./infiniloom.linux-arm-musleabihf.node')
+            } else {
+              nativeBinding = require('@infiniloom/node-linux-arm-musleabihf')
+            }
+          } catch (e) {
+            loadError = e
+          }
+        } else {
+          localFileExisted = existsSync(
+            join(__dirname, 'infiniloom.linux-arm-gnueabihf.node')
+          )
+          try {
+            if (localFileExisted) {
+              nativeBinding = require('./infiniloom.linux-arm-gnueabihf.node')
+            } else {
+              nativeBinding = require('@infiniloom/node-linux-arm-gnueabihf')
+            }
+          } catch (e) {
+            loadError = e
+          }
+        }
+        break
+      case 'riscv64':
+        if (isMusl()) {
+          localFileExisted = existsSync(
+            join(__dirname, 'infiniloom.linux-riscv64-musl.node')
+          )
+          try {
+            if (localFileExisted) {
+              nativeBinding = require('./infiniloom.linux-riscv64-musl.node')
+            } else {
+              nativeBinding = require('@infiniloom/node-linux-riscv64-musl')
+            }
+          } catch (e) {
+            loadError = e
+          }
+        } else {
+          localFileExisted = existsSync(
+            join(__dirname, 'infiniloom.linux-riscv64-gnu.node')
+          )
+          try {
+            if (localFileExisted) {
+              nativeBinding = require('./infiniloom.linux-riscv64-gnu.node')
+            } else {
+              nativeBinding = require('@infiniloom/node-linux-riscv64-gnu')
+            }
+          } catch (e) {
+            loadError = e
+          }
+        }
+        break
+      case 's390x':
+        localFileExisted = existsSync(
+          join(__dirname, 'infiniloom.linux-s390x-gnu.node')
+        )
+        try {
+          if (localFileExisted) {
+            nativeBinding = require('./infiniloom.linux-s390x-gnu.node')
+          } else {
+            nativeBinding = require('@infiniloom/node-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 { pack, scan, countTokens, Infiniloom, semanticCompress, isGitRepo, GitRepo } = nativeBinding
+
+module.exports.pack = pack
+module.exports.scan = scan
+module.exports.countTokens = countTokens
+module.exports.Infiniloom = Infiniloom
+module.exports.semanticCompress = semanticCompress
+module.exports.isGitRepo = isGitRepo
+module.exports.GitRepo = GitRepo

package/package.json

@@ -0,0 +1,66 @@
+{
+  "name": "infiniloom-node",
+  "version": "0.1.0",
+  "description": "Node.js bindings for infiniloom - Repository context engine for LLMs",
+  "main": "index.js",
+  "types": "index.d.ts",
+  "napi": {
+    "name": "infiniloom",
+    "triples": {
+      "defaults": true,
+      "additional": [
+        "x86_64-unknown-linux-musl",
+        "aarch64-unknown-linux-gnu",
+        "armv7-unknown-linux-gnueabihf",
+        "aarch64-apple-darwin",
+        "aarch64-linux-android",
+        "x86_64-unknown-freebsd",
+        "aarch64-unknown-linux-musl",
+        "aarch64-pc-windows-msvc"
+      ]
+    }
+  },
+  "author": "Topos Labs",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/Topos-Labs/infiniloom.git",
+    "directory": "bindings/node"
+  },
+  "keywords": [
+    "infiniloom",
+    "llm",
+    "context",
+    "repository",
+    "code-analysis",
+    "napi-rs",
+    "rust"
+  ],
+  "engines": {
+    "node": ">= 16"
+  },
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org/",
+    "access": "public"
+  },
+  "scripts": {
+    "artifacts": "napi artifacts",
+    "build": "napi build --platform --release",
+    "build:debug": "napi build --platform",
+    "prepublishOnly": "napi prepublish -t npm",
+    "test": "node --test",
+    "version": "napi version"
+  },
+  "devDependencies": {
+    "@napi-rs/cli": "^2.18.0"
+  },
+  "files": [
+    "index.js",
+    "index.d.ts",
+    "*.node"
+  ],
+  "bugs": {
+    "url": "https://github.com/Topos-Labs/infiniloom/issues"
+  },
+  "homepage": "https://github.com/Topos-Labs/infiniloom#readme"
+}