recursive-llm-ts 5.2.6 → 5.2.10

package/dist/cjs/bridge-factory.js

@@ -58,18 +58,61 @@ const PLATFORM_PACKAGES = {
     'linux-arm64': '@recursive-llm/linux-arm64',
     'win32-x64': '@recursive-llm/win32-x64',
 };
+/**
+ * Walk up the directory tree from PKG_ROOT_DIR, looking for the platform
+ * package binary inside node_modules directories. This handles pnpm's strict
+ * isolation where require.resolve() cannot find optional dependencies.
+ */
+function findBinaryInNodeModules(pkgName) {
+    let dir = pkg_dir_1.PKG_ROOT_DIR;
+    const seenDirs = new Set();
+    while (dir && !seenDirs.has(dir)) {
+        seenDirs.add(dir);
+        // Standard node_modules layout (npm, yarn)
+        const candidate = path.join(dir, 'node_modules', pkgName, 'bin', DEFAULT_GO_BINARY);
+        if (fs.existsSync(candidate))
+            return true;
+        // pnpm .pnpm directory
+        const pnpmDir = path.join(dir, 'node_modules', '.pnpm');
+        if (fs.existsSync(pnpmDir)) {
+            const pnpmName = pkgName.replace('/', '+');
+            try {
+                const entries = fs.readdirSync(pnpmDir);
+                for (const entry of entries) {
+                    if (entry.startsWith(pnpmName + '@')) {
+                        const pnpmCandidate = path.join(pnpmDir, entry, 'node_modules', pkgName, 'bin', DEFAULT_GO_BINARY);
+                        if (fs.existsSync(pnpmCandidate))
+                            return true;
+                    }
+                }
+            }
+            catch (_a) {
+                // Permission error or similar — skip
+            }
+        }
+        const parent = path.dirname(dir);
+        if (parent === dir)
+            break;
+        dir = parent;
+    }
+    return false;
+}
 function isPlatformBinaryAvailable() {
     const key = `${process.platform}-${process.arch}`;
     const pkgName = PLATFORM_PACKAGES[key];
     if (!pkgName)
         return false;
+    // 1. Try require.resolve (works with npm, yarn, and non-strict pnpm)
     try {
         const pkgDir = path.dirname(require.resolve(`${pkgName}/package.json`));
-        return fs.existsSync(path.join(pkgDir, 'bin', DEFAULT_GO_BINARY));
+        if (fs.existsSync(path.join(pkgDir, 'bin', DEFAULT_GO_BINARY)))
+            return true;
     }
     catch (_a) {
-        return false;
+        // Fall through to filesystem search
     }
+    // 2. Walk up directory tree looking in node_modules (handles pnpm strict isolation)
+    return findBinaryInNodeModules(pkgName);
 }
 function isGoBinaryAvailable() {
     const envPath = process.env.RLM_GO_BINARY;

package/dist/cjs/go-bridge.js

@@ -67,6 +67,48 @@ const PLATFORM_PACKAGES = {
     'linux-arm64': '@recursive-llm/linux-arm64',
     'win32-x64': '@recursive-llm/win32-x64',
 };
+/**
+ * Walk up the directory tree from a starting point, looking for the platform
+ * package binary inside node_modules directories. This handles pnpm's strict
+ * isolation where require.resolve() cannot find optional dependencies.
+ */
+function findBinaryInNodeModules(pkgName) {
+    let dir = pkg_dir_1.PKG_ROOT_DIR;
+    const seenDirs = new Set();
+    while (dir && !seenDirs.has(dir)) {
+        seenDirs.add(dir);
+        // Standard node_modules layout (npm, yarn)
+        const candidate = path.join(dir, 'node_modules', pkgName, 'bin', DEFAULT_BINARY_NAME);
+        if (fs.existsSync(candidate))
+            return candidate;
+        // pnpm hoisted node_modules (the package may be hoisted even under pnpm)
+        // Also check .pnpm directory where pnpm stores the actual package contents
+        const pnpmDir = path.join(dir, 'node_modules', '.pnpm');
+        if (fs.existsSync(pnpmDir)) {
+            // pnpm stores packages as: .pnpm/<name>@<version>/node_modules/<name>/
+            // where scoped packages use + instead of / in the directory name
+            const pnpmName = pkgName.replace('/', '+');
+            try {
+                const entries = fs.readdirSync(pnpmDir);
+                for (const entry of entries) {
+                    if (entry.startsWith(pnpmName + '@')) {
+                        const pnpmCandidate = path.join(pnpmDir, entry, 'node_modules', pkgName, 'bin', DEFAULT_BINARY_NAME);
+                        if (fs.existsSync(pnpmCandidate))
+                            return pnpmCandidate;
+                    }
+                }
+            }
+            catch (_a) {
+                // Permission error or similar — skip
+            }
+        }
+        const parent = path.dirname(dir);
+        if (parent === dir)
+            break;
+        dir = parent;
+    }
+    return null;
+}
 function resolvePlatformBinary() {
     const platform = process.platform;
     const arch = process.arch;
@@ -74,17 +116,18 @@ function resolvePlatformBinary() {
     const pkgName = PLATFORM_PACKAGES[key];
     if (!pkgName)
         return null;
+    // 1. Try require.resolve (works with npm, yarn, and non-strict pnpm)
     try {
-        // require.resolve works in both CJS and ESM (via createRequire)
         const pkgDir = path.dirname(require.resolve(`${pkgName}/package.json`));
         const binPath = path.join(pkgDir, 'bin', DEFAULT_BINARY_NAME);
         if (fs.existsSync(binPath))
             return binPath;
     }
     catch (_a) {
-        // Package not installed — fall through
+        // Package not resolvable via require — fall through to filesystem search
     }
-    return null;
+    // 2. Walk up directory tree looking in node_modules (handles pnpm strict isolation)
+    return findBinaryInNodeModules(pkgName);
 }
 function resolveBinaryPath(rlmConfig) {
     const configuredPath = rlmConfig.go_binary_path || process.env.RLM_GO_BINARY;

package/dist/esm/bridge-factory.js

@@ -22,18 +22,61 @@ const PLATFORM_PACKAGES = {
     'linux-arm64': '@recursive-llm/linux-arm64',
     'win32-x64': '@recursive-llm/win32-x64',
 };
+/**
+ * Walk up the directory tree from PKG_ROOT_DIR, looking for the platform
+ * package binary inside node_modules directories. This handles pnpm's strict
+ * isolation where require.resolve() cannot find optional dependencies.
+ */
+function findBinaryInNodeModules(pkgName) {
+    let dir = PKG_ROOT_DIR;
+    const seenDirs = new Set();
+    while (dir && !seenDirs.has(dir)) {
+        seenDirs.add(dir);
+        // Standard node_modules layout (npm, yarn)
+        const candidate = path.join(dir, 'node_modules', pkgName, 'bin', DEFAULT_GO_BINARY);
+        if (fs.existsSync(candidate))
+            return true;
+        // pnpm .pnpm directory
+        const pnpmDir = path.join(dir, 'node_modules', '.pnpm');
+        if (fs.existsSync(pnpmDir)) {
+            const pnpmName = pkgName.replace('/', '+');
+            try {
+                const entries = fs.readdirSync(pnpmDir);
+                for (const entry of entries) {
+                    if (entry.startsWith(pnpmName + '@')) {
+                        const pnpmCandidate = path.join(pnpmDir, entry, 'node_modules', pkgName, 'bin', DEFAULT_GO_BINARY);
+                        if (fs.existsSync(pnpmCandidate))
+                            return true;
+                    }
+                }
+            }
+            catch (_a) {
+                // Permission error or similar — skip
+            }
+        }
+        const parent = path.dirname(dir);
+        if (parent === dir)
+            break;
+        dir = parent;
+    }
+    return false;
+}
 function isPlatformBinaryAvailable() {
     const key = `${process.platform}-${process.arch}`;
     const pkgName = PLATFORM_PACKAGES[key];
     if (!pkgName)
         return false;
+    // 1. Try require.resolve (works with npm, yarn, and non-strict pnpm)
     try {
         const pkgDir = path.dirname(require.resolve(`${pkgName}/package.json`));
-        return fs.existsSync(path.join(pkgDir, 'bin', DEFAULT_GO_BINARY));
+        if (fs.existsSync(path.join(pkgDir, 'bin', DEFAULT_GO_BINARY)))
+            return true;
     }
     catch (_a) {
-        return false;
+        // Fall through to filesystem search
     }
+    // 2. Walk up directory tree looking in node_modules (handles pnpm strict isolation)
+    return findBinaryInNodeModules(pkgName);
 }
 function isGoBinaryAvailable() {
     const envPath = process.env.RLM_GO_BINARY;

package/dist/esm/go-bridge.js

@@ -31,6 +31,48 @@ const PLATFORM_PACKAGES = {
     'linux-arm64': '@recursive-llm/linux-arm64',
     'win32-x64': '@recursive-llm/win32-x64',
 };
+/**
+ * Walk up the directory tree from a starting point, looking for the platform
+ * package binary inside node_modules directories. This handles pnpm's strict
+ * isolation where require.resolve() cannot find optional dependencies.
+ */
+function findBinaryInNodeModules(pkgName) {
+    let dir = PKG_ROOT_DIR;
+    const seenDirs = new Set();
+    while (dir && !seenDirs.has(dir)) {
+        seenDirs.add(dir);
+        // Standard node_modules layout (npm, yarn)
+        const candidate = path.join(dir, 'node_modules', pkgName, 'bin', DEFAULT_BINARY_NAME);
+        if (fs.existsSync(candidate))
+            return candidate;
+        // pnpm hoisted node_modules (the package may be hoisted even under pnpm)
+        // Also check .pnpm directory where pnpm stores the actual package contents
+        const pnpmDir = path.join(dir, 'node_modules', '.pnpm');
+        if (fs.existsSync(pnpmDir)) {
+            // pnpm stores packages as: .pnpm/<name>@<version>/node_modules/<name>/
+            // where scoped packages use + instead of / in the directory name
+            const pnpmName = pkgName.replace('/', '+');
+            try {
+                const entries = fs.readdirSync(pnpmDir);
+                for (const entry of entries) {
+                    if (entry.startsWith(pnpmName + '@')) {
+                        const pnpmCandidate = path.join(pnpmDir, entry, 'node_modules', pkgName, 'bin', DEFAULT_BINARY_NAME);
+                        if (fs.existsSync(pnpmCandidate))
+                            return pnpmCandidate;
+                    }
+                }
+            }
+            catch (_a) {
+                // Permission error or similar — skip
+            }
+        }
+        const parent = path.dirname(dir);
+        if (parent === dir)
+            break;
+        dir = parent;
+    }
+    return null;
+}
 function resolvePlatformBinary() {
     const platform = process.platform;
     const arch = process.arch;
@@ -38,17 +80,18 @@ function resolvePlatformBinary() {
     const pkgName = PLATFORM_PACKAGES[key];
     if (!pkgName)
         return null;
+    // 1. Try require.resolve (works with npm, yarn, and non-strict pnpm)
     try {
-        // require.resolve works in both CJS and ESM (via createRequire)
         const pkgDir = path.dirname(require.resolve(`${pkgName}/package.json`));
         const binPath = path.join(pkgDir, 'bin', DEFAULT_BINARY_NAME);
         if (fs.existsSync(binPath))
             return binPath;
     }
     catch (_a) {
-        // Package not installed — fall through
+        // Package not resolvable via require — fall through to filesystem search
     }
-    return null;
+    // 2. Walk up directory tree looking in node_modules (handles pnpm strict isolation)
+    return findBinaryInNodeModules(pkgName);
 }
 function resolveBinaryPath(rlmConfig) {
     const configuredPath = rlmConfig.go_binary_path || process.env.RLM_GO_BINARY;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "recursive-llm-ts",
-  "version": "5.2.6",
+  "version": "5.2.10",
   "description": "TypeScript bridge for recursive-llm: Recursive Language Models for unbounded context processing with structured outputs",
   "main": "dist/cjs/index.js",
   "module": "dist/esm/index.js",
@@ -88,10 +88,10 @@
     }
   },
   "optionalDependencies": {
-    "@recursive-llm/darwin-arm64": "5.2.6",
-    "@recursive-llm/darwin-x64": "5.2.6",
-    "@recursive-llm/linux-x64": "5.2.6",
-    "@recursive-llm/linux-arm64": "5.2.6",
-    "@recursive-llm/win32-x64": "5.2.6"
+    "@recursive-llm/darwin-arm64": "5.2.10",
+    "@recursive-llm/darwin-x64": "5.2.10",
+    "@recursive-llm/linux-x64": "5.2.10",
+    "@recursive-llm/linux-arm64": "5.2.10",
+    "@recursive-llm/win32-x64": "5.2.10"
   }
 }

package/scripts/build-go-binary.js

@@ -21,7 +21,49 @@ const PLATFORM_PACKAGES = {
 const platformKey = `${process.platform}-${process.arch}`;
 const platformPkg = PLATFORM_PACKAGES[platformKey];
 
+/**
+ * Walk up the directory tree from repoRoot looking for the platform package
+ * binary inside node_modules directories. Handles pnpm's strict isolation
+ * where require.resolve() cannot find optional dependencies.
+ */
+function findBinaryInNodeModules(pkgName) {
+  let dir = repoRoot;
+  const seenDirs = new Set();
+  while (dir && !seenDirs.has(dir)) {
+    seenDirs.add(dir);
+
+    // Standard node_modules layout (npm, yarn)
+    const candidate = path.join(dir, 'node_modules', pkgName, 'bin', binaryName);
+    if (fs.existsSync(candidate)) return candidate;
+
+    // pnpm .pnpm directory
+    const pnpmDir = path.join(dir, 'node_modules', '.pnpm');
+    if (fs.existsSync(pnpmDir)) {
+      const pnpmName = pkgName.replace('/', '+');
+      try {
+        const entries = fs.readdirSync(pnpmDir);
+        for (const entry of entries) {
+          if (entry.startsWith(pnpmName + '@')) {
+            const pnpmCandidate = path.join(
+              pnpmDir, entry, 'node_modules', pkgName, 'bin', binaryName
+            );
+            if (fs.existsSync(pnpmCandidate)) return pnpmCandidate;
+          }
+        }
+      } catch {
+        // Permission error or similar — skip
+      }
+    }
+
+    const parent = path.dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  return null;
+}
+
 if (platformPkg) {
+  // 1. Try require.resolve (works with npm, yarn, and non-strict pnpm)
   try {
     const pkgDir = path.dirname(require.resolve(`${platformPkg}/package.json`));
     const platformBinary = path.join(pkgDir, 'bin', binaryName);
@@ -30,7 +72,14 @@ if (platformPkg) {
       process.exit(0);
     }
   } catch {
-    // Package not installed — continue to local build
+    // Package not resolvable via require — fall through to filesystem search
+  }
+
+  // 2. Walk up directory tree looking in node_modules (handles pnpm strict isolation)
+  const found = findBinaryInNodeModules(platformPkg);
+  if (found) {
+    console.log(`[recursive-llm-ts] ✓ Pre-built binary found at ${found}`);
+    process.exit(0);
   }
 }