@sylphai/adal-cli 0.1.0-beta.101

package/bin/adal-cli.js

@@ -0,0 +1,155 @@
+#!/usr/bin/env node
+
+/**
+ * Main entry point for @sylphai/adal-cli (v2 - with caching)
+ * This wrapper uses cached platform package path for better performance
+ */
+
+const { spawn } = require('child_process');
+const path = require('path');
+const fs = require('fs');
+const os = require('os');
+
+// Determine current platform
+const platform = os.platform();
+const arch = os.arch();
+
+// Map Node.js platform/arch to our package naming
+const platformMap = {
+  'darwin-arm64': '@sylphai/adal-cli-darwin-arm64',
+  'darwin-x64': '@sylphai/adal-cli-darwin-x64',
+  'linux-x64': '@sylphai/adal-cli-linux-x64',
+  'linux-arm64': '@sylphai/adal-cli-linux-arm64',
+  'win32-x64': '@sylphai/adal-cli-win32-x64',
+  'win32-ia32': '@sylphai/adal-cli-win32-x64', // Use x64 for 32-bit Windows too
+};
+
+const platformKey = `${platform}-${arch}`;
+const packageName = platformMap[platformKey];
+
+if (!packageName) {
+  console.error(`❌ Unsupported platform: ${platform}-${arch}`);
+  console.error('Supported platforms:');
+  Object.keys(platformMap).forEach(key => {
+    console.error(`  - ${key}`);
+  });
+  process.exit(1);
+}
+
+// Cache file location
+const cacheDir = path.join(__dirname, '..', '.cache');
+const cacheFile = path.join(cacheDir, 'platform-path.json');
+
+// Try to load cached path first
+function loadCachedPath() {
+  try {
+    if (fs.existsSync(cacheFile)) {
+      const cache = JSON.parse(fs.readFileSync(cacheFile, 'utf8'));
+      // Verify the cached path still exists
+      if (cache.path && fs.existsSync(cache.path)) {
+        // Check if it's been less than 30 days since last cache
+        const cacheAge = Date.now() - cache.timestamp;
+        if (cacheAge < 30 * 24 * 60 * 60 * 1000) { // 30 days in milliseconds
+          return cache.path;
+        }
+      }
+    }
+  } catch (e) {
+    // Cache read failed, will find path normally
+  }
+  return null;
+}
+
+// Save path to cache
+function saveCachedPath(platformPath) {
+  try {
+    if (!fs.existsSync(cacheDir)) {
+      fs.mkdirSync(cacheDir, { recursive: true });
+    }
+    fs.writeFileSync(cacheFile, JSON.stringify({
+      path: platformPath,
+      platform: platformKey,
+      package: packageName,
+      timestamp: Date.now()
+    }, null, 2));
+  } catch (e) {
+    // Cache write failed, not critical
+  }
+}
+
+// Find the platform-specific package
+function findPlatformPackage() {
+  // Try cached path first
+  const cachedPath = loadCachedPath();
+  if (cachedPath) {
+    // Double-check the cached path still works
+    if (fs.existsSync(cachedPath)) {
+      return cachedPath;
+    }
+    // Cached path is stale, will search again and update cache
+  }
+
+  // If no cache or cache is stale, search for the package
+  const possiblePaths = [
+    // When installed globally
+    path.join(__dirname, '..', '..', packageName, 'adal-cli.js'),
+    // When installed locally in a project
+    path.join(process.cwd(), 'node_modules', packageName, 'adal-cli.js'),
+    // When running from development
+    path.join(__dirname, '..', 'node_modules', packageName, 'adal-cli.js'),
+    // Alternative global location
+    require.resolve.paths(packageName).map(p => path.join(p, packageName, 'adal-cli.js')).filter(Boolean)
+  ].flat();
+
+  for (const testPath of possiblePaths) {
+    if (fs.existsSync(testPath)) {
+      saveCachedPath(testPath); // Cache the found path
+      return testPath;
+    }
+  }
+
+  // Try using require.resolve as last resort
+  try {
+    const packagePath = require.resolve(`${packageName}/package.json`);
+    const platformBinary = path.join(path.dirname(packagePath), 'adal-cli.js');
+    if (fs.existsSync(platformBinary)) {
+      saveCachedPath(platformBinary); // Cache the found path
+      return platformBinary;
+    }
+  } catch (e) {
+    // Package not found
+  }
+
+  return null;
+}
+
+const platformBinary = findPlatformPackage();
+
+if (!platformBinary) {
+  console.error(`❌ Platform package ${packageName} not found!`);
+  console.error('');
+  console.error('The platform-specific package should be installed automatically.');
+  console.error('If it\'s not, you can install it manually:');
+  console.error(`  npm install ${packageName}`);
+  console.error('');
+  console.error('If you\'re using npm < 7, optional dependencies might not install automatically.');
+  console.error('Please upgrade npm or install the platform package manually.');
+  process.exit(1);
+}
+
+// Execute the platform-specific binary with all arguments
+const child = spawn(process.execPath, [platformBinary, ...process.argv.slice(2)], {
+  stdio: 'inherit',
+  env: process.env,
+});
+
+// Forward the exit code
+child.on('exit', (code) => {
+  process.exit(code || 0);
+});
+
+// Handle errors
+child.on('error', (error) => {
+  console.error(`❌ Failed to execute platform binary: ${error.message}`);
+  process.exit(1);
+});

package/lib/platform-resolver.js

@@ -0,0 +1,50 @@
+/**
+ * Platform resolver utilities
+ * Can be used programmatically to find the correct platform package
+ */
+
+const os = require('os');
+const path = require('path');
+const fs = require('fs');
+
+const platformMap = {
+  'darwin-arm64': '@sylphai/adal-cli-darwin-arm64',
+  'darwin-x64': '@sylphai/adal-cli-darwin-x64',
+  'linux-x64': '@sylphai/adal-cli-linux-x64',
+  'linux-arm64': '@sylphai/adal-cli-linux-arm64',
+  'win32-x64': '@sylphai/adal-cli-win32-x64',
+  'win32-ia32': '@sylphai/adal-cli-win32-x64',
+};
+
+function getCurrentPlatformPackage() {
+  const platform = os.platform();
+  const arch = os.arch();
+  const platformKey = `${platform}-${arch}`;
+  return platformMap[platformKey];
+}
+
+function isPlatformSupported() {
+  return getCurrentPlatformPackage() !== undefined;
+}
+
+function getCachedPath() {
+  const cacheFile = path.join(__dirname, '..', '.cache', 'platform-path.json');
+  try {
+    if (fs.existsSync(cacheFile)) {
+      const cache = JSON.parse(fs.readFileSync(cacheFile, 'utf8'));
+      if (cache.path && fs.existsSync(cache.path)) {
+        return cache;
+      }
+    }
+  } catch (e) {
+    // Cache read failed
+  }
+  return null;
+}
+
+module.exports = {
+  getCurrentPlatformPackage,
+  isPlatformSupported,
+  getCachedPath,
+  platformMap,
+};

package/lib/setup-cache.js

@@ -0,0 +1,108 @@
+#!/usr/bin/env node
+
+/**
+ * Post-install script to pre-cache the platform package path
+ * This runs during npm install to find and cache the platform package location
+ */
+
+const path = require('path');
+const fs = require('fs');
+const os = require('os');
+
+// Determine current platform
+const platform = os.platform();
+const arch = os.arch();
+
+const platformMap = {
+  'darwin-arm64': '@sylphai/adal-cli-darwin-arm64',
+  'darwin-x64': '@sylphai/adal-cli-darwin-x64',
+  'linux-x64': '@sylphai/adal-cli-linux-x64',
+  'linux-arm64': '@sylphai/adal-cli-linux-arm64',
+  'win32-x64': '@sylphai/adal-cli-win32-x64',
+  'win32-ia32': '@sylphai/adal-cli-win32-x64',
+};
+
+const platformKey = `${platform}-${arch}`;
+const packageName = platformMap[platformKey];
+
+if (!packageName) {
+  // Unsupported platform, skip caching
+  process.exit(0);
+}
+
+// Cache file location
+const cacheDir = path.join(__dirname, '..', '.cache');
+const cacheFile = path.join(cacheDir, 'platform-path.json');
+
+// Find the platform package during installation
+function findAndCachePlatformPackage() {
+  const possiblePaths = [
+    // When installed globally
+    path.join(__dirname, '..', '..', packageName, 'adal-cli.js'),
+    // When installed locally in a project
+    path.join(process.cwd(), 'node_modules', packageName, 'adal-cli.js'),
+    // When running from development
+    path.join(__dirname, '..', 'node_modules', packageName, 'adal-cli.js'),
+  ];
+
+  // Also check require.resolve paths
+  try {
+    const resolvePaths = require.resolve.paths(packageName);
+    if (resolvePaths) {
+      resolvePaths.forEach(p => {
+        possiblePaths.push(path.join(p, packageName, 'adal-cli.js'));
+      });
+    }
+  } catch (e) {
+    // Ignore errors
+  }
+
+  for (const testPath of possiblePaths) {
+    if (fs.existsSync(testPath)) {
+      // Found the platform package, cache it
+      try {
+        if (!fs.existsSync(cacheDir)) {
+          fs.mkdirSync(cacheDir, { recursive: true });
+        }
+        fs.writeFileSync(cacheFile, JSON.stringify({
+          path: testPath,
+          platform: platformKey,
+          package: packageName,
+          timestamp: Date.now(),
+          installedAt: new Date().toISOString()
+        }, null, 2));
+        console.log(`✅ Cached platform package path: ${packageName}`);
+      } catch (e) {
+        // Cache write failed, not critical
+        console.log(`⚠️  Could not cache platform package path: ${e.message}`);
+      }
+      return;
+    }
+  }
+
+  // Try using require.resolve as last resort
+  try {
+    const packagePath = require.resolve(`${packageName}/package.json`);
+    const platformBinary = path.join(path.dirname(packagePath), 'adal-cli.js');
+    if (fs.existsSync(platformBinary)) {
+      // Cache the found path
+      if (!fs.existsSync(cacheDir)) {
+        fs.mkdirSync(cacheDir, { recursive: true });
+      }
+      fs.writeFileSync(cacheFile, JSON.stringify({
+        path: platformBinary,
+        platform: platformKey,
+        package: packageName,
+        timestamp: Date.now(),
+        installedAt: new Date().toISOString()
+      }, null, 2));
+      console.log(`✅ Cached platform package path: ${packageName}`);
+    }
+  } catch (e) {
+    // Platform package not found during install, will be found at runtime
+    console.log(`⚠️  Platform package ${packageName} not found during install, will detect at runtime`);
+  }
+}
+
+// Run the caching
+findAndCachePlatformPackage();

package/package.json

@@ -0,0 +1,32 @@
+{
+  "name": "@sylphai/adal-cli",
+  "version": "0.1.0-beta.101",
+  "description": "AI-powered CLI for development and research tasks",
+  "bin": {
+    "adal": "bin/adal-cli.js"
+  },
+  "scripts": {
+    "postinstall": "node lib/setup-cache.js"
+  },
+  "optionalDependencies": {
+    "@sylphai/adal-cli-darwin-arm64": "0.1.0-beta.101",
+    "@sylphai/adal-cli-darwin-x64": "0.1.0-beta.101",
+    "@sylphai/adal-cli-linux-x64": "0.1.0-beta.101",
+    "@sylphai/adal-cli-linux-arm64": "0.1.0-beta.101",
+    "@sylphai/adal-cli-win32-x64": "0.1.0-beta.101"
+  },
+  "files": [
+    "bin/",
+    "lib/"
+  ],
+  "keywords": ["ai", "cli", "development", "research", "assistant"],
+  "author": "SylphAI",
+  "license": "SylphAI Proprietary",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/SylphAI-Inc/adal-cli.git"
+  },
+  "engines": {
+    "node": ">=14.0.0"
+  }
+}