ai-rulez 1.6.0 → 2.0.0

package/bin/ai-rulez.js

@@ -0,0 +1,66 @@
+#!/usr/bin/env node
+
+const fs = require("node:fs");
+const path = require("node:path");
+const { spawn } = require("node:child_process");
+
+// Import the install logic from install.js
+const installPath = path.join(__dirname, "..", "install.js");
+const installer = require(installPath);
+
+const BINARY_NAME = installer.getBinaryName();
+const BINARY_PATH = path.join(__dirname, BINARY_NAME);
+
+async function ensureBinary() {
+	if (fs.existsSync(BINARY_PATH)) {
+		return true;
+	}
+
+	console.log("🚀 First run detected - downloading ai-rulez binary...");
+	console.log("   This will only happen once and takes a few seconds.");
+	console.log("");
+	try {
+		await installer.install();
+		if (fs.existsSync(BINARY_PATH)) {
+			console.log("✅ Download complete! Running ai-rulez...");
+			console.log("");
+			return true;
+		} else {
+			throw new Error("Binary not found after installation");
+		}
+	} catch (error) {
+		console.error("❌ Failed to download ai-rulez binary:", error.message);
+		process.exit(1);
+	}
+}
+
+async function main() {
+	const hasBinary = await ensureBinary();
+
+	if (!hasBinary) {
+		console.error("Could not find or download ai-rulez binary");
+		process.exit(1);
+	}
+
+	// Forward all arguments to the native binary
+	const child = spawn(BINARY_PATH, process.argv.slice(2), {
+		stdio: "inherit",
+		cwd: process.cwd(),
+	});
+
+	child.on("exit", (code) => {
+		process.exit(code || 0);
+	});
+
+	child.on("error", (error) => {
+		console.error("Failed to start ai-rulez:", error.message);
+		process.exit(1);
+	});
+}
+
+if (require.main === module) {
+	main().catch((error) => {
+		console.error("Error:", error.message);
+		process.exit(1);
+	});
+}

package/install.js

@@ -1,415 +1,446 @@
-const fs = require('fs');
-const path = require('path');
-const https = require('https');
-const http = require('http');
-const crypto = require('crypto');
-const { exec, spawn } = require('child_process');
-const { promisify } = require('util');
-
-const execAsync = promisify(exec);
-
-const REPO_NAME = 'Goldziher/ai-rulez';
-const DOWNLOAD_TIMEOUT = 30000; // 30 seconds
+const fs = require("node:fs");
+const path = require("node:path");
+const https = require("node:https");
+const http = require("node:http");
+const crypto = require("node:crypto");
+const { exec, spawn } = require("node:child_process");
+const { promisify } = require("node:util");
+
+const _execAsync = promisify(exec);
+
+const REPO_NAME = "Goldziher/ai-rulez";
+const DOWNLOAD_TIMEOUT = 30000;
 const MAX_RETRIES = 3;
-const RETRY_DELAY = 2000; // 2 seconds
+const RETRY_DELAY = 2000;
 
 async function calculateSHA256(filePath) {
-  return new Promise((resolve, reject) => {
-    const hash = crypto.createHash('sha256');
-    const stream = fs.createReadStream(filePath);
-    
-    stream.on('data', (data) => hash.update(data));
-    stream.on('end', () => resolve(hash.digest('hex')));
-    stream.on('error', reject);
-  });
+	return new Promise((resolve, reject) => {
+		const hash = crypto.createHash("sha256");
+		const stream = fs.createReadStream(filePath);
+
+		stream.on("data", (data) => hash.update(data));
+		stream.on("end", () => resolve(hash.digest("hex")));
+		stream.on("error", reject);
+	});
 }
 
 async function getExpectedChecksum(checksumPath, filename) {
-  try {
-    const checksumContent = fs.readFileSync(checksumPath, 'utf8');
-    const lines = checksumContent.split('\n');
-    
-    for (const line of lines) {
-      const parts = line.trim().split(/\s+/);
-      if (parts.length >= 2 && parts[1] === filename) {
-        return parts[0];
-      }
-    }
-    return null;
-  } catch (error) {
-    console.warn('Warning: Could not parse checksums file:', error.message);
-    return null;
-  }
+	try {
+		const checksumContent = fs.readFileSync(checksumPath, "utf8");
+		const lines = checksumContent.split("\n");
+
+		for (const line of lines) {
+			const parts = line.trim().split(/\s+/);
+			if (parts.length >= 2 && parts[1] === filename) {
+				return parts[0];
+			}
+		}
+		return null;
+	} catch (error) {
+		console.warn("Warning: Could not parse checksums file:", error.message);
+		return null;
+	}
 }
 
 function getPlatform() {
-  const platform = process.platform;
-  const arch = process.arch;
-  
-  const platformMap = {
-    'darwin': 'darwin',
-    'linux': 'linux',
-    'win32': 'windows'
-  };
-  
-  const archMap = {
-    'x64': 'amd64',
-    'arm64': 'arm64',
-    'ia32': '386',
-    'x32': '386'
-  };
-  
-  const mappedPlatform = platformMap[platform];
-  const mappedArch = archMap[arch];
-  
-  if (!mappedPlatform) {
-    throw new Error(`Unsupported operating system: ${platform}. Supported platforms: darwin (macOS), linux, win32 (Windows)`);
-  }
-  
-  if (!mappedArch) {
-    throw new Error(`Unsupported architecture: ${arch}. Supported architectures: x64, arm64, ia32`);
-  }
-  
-  
-  if (mappedPlatform === 'windows' && mappedArch === 'arm64') {
-    throw new Error('Windows ARM64 is not currently supported. Please use x64 or ia32 version.');
-  }
-  
-  return {
-    os: mappedPlatform,
-    arch: mappedArch
-  };
+	const platform = process.platform;
+	const arch = process.arch;
+
+	const platformMap = {
+		darwin: "darwin",
+		linux: "linux",
+		win32: "windows",
+	};
+
+	const archMap = {
+		x64: "amd64",
+		arm64: "arm64",
+		ia32: "386",
+		x32: "386",
+	};
+
+	const mappedPlatform = platformMap[platform];
+	const mappedArch = archMap[arch];
+
+	if (!mappedPlatform) {
+		throw new Error(
+			`Unsupported operating system: ${platform}. Supported platforms: darwin (macOS), linux, win32 (Windows)`,
+		);
+	}
+
+	if (!mappedArch) {
+		throw new Error(
+			`Unsupported architecture: ${arch}. Supported architectures: x64, arm64, ia32`,
+		);
+	}
+
+	if (mappedPlatform === "windows" && mappedArch === "arm64") {
+		throw new Error(
+			"Windows ARM64 is not currently supported. Please use x64 or ia32 version.",
+		);
+	}
+
+	return {
+		os: mappedPlatform,
+		arch: mappedArch,
+	};
 }
 
 function getBinaryName(platform) {
-  // Use a different name to avoid conflict with the wrapper script
-  return platform === 'windows' ? 'ai-rulez-bin.exe' : 'ai-rulez-bin';
+	return platform === "windows" ? "ai-rulez-bin.exe" : "ai-rulez-bin";
 }
 
 async function downloadBinary(url, dest, retryCount = 0) {
-  return new Promise((resolve, reject) => {
-    const file = fs.createWriteStream(dest);
-    const protocol = url.startsWith('https') ? https : http;
-    
-    const request = protocol.get(url, { timeout: DOWNLOAD_TIMEOUT }, (response) => {
-      if (response.statusCode === 302 || response.statusCode === 301) {
-        file.close();
-        try { fs.unlinkSync(dest); } catch {} // Clean up partial file
-        downloadBinary(response.headers.location, dest, retryCount)
-          .then(resolve)
-          .catch(reject);
-        return;
-      }
-      
-      if (response.statusCode !== 200) {
-        file.close();
-        try { fs.unlinkSync(dest); } catch {} // Clean up partial file
-        const error = new Error(`HTTP ${response.statusCode}: ${response.statusMessage}`);
-        
-        if (retryCount < MAX_RETRIES) {
-          console.log(`Download failed, retrying in ${RETRY_DELAY/1000}s... (${retryCount + 1}/${MAX_RETRIES})`);
-          setTimeout(() => {
-            downloadBinary(url, dest, retryCount + 1)
-              .then(resolve)
-              .catch(reject);
-          }, RETRY_DELAY);
-          return;
-        }
-        
-        reject(error);
-        return;
-      }
-      
-      let downloadedBytes = 0;
-      response.on('data', (chunk) => {
-        downloadedBytes += chunk.length;
-      });
-      
-      response.pipe(file);
-      
-      file.on('finish', () => {
-        file.close();
-        if (downloadedBytes === 0) {
-          try { fs.unlinkSync(dest); } catch {}
-          reject(new Error('Downloaded file is empty'));
-          return;
-        }
-        console.log(`Downloaded ${downloadedBytes} bytes`);
-        resolve();
-      });
-      
-      file.on('error', (err) => {
-        file.close();
-        try { fs.unlinkSync(dest); } catch {}
-        reject(err);
-      });
-    });
-    
-    request.on('timeout', () => {
-      request.destroy();
-      file.close();
-      try { fs.unlinkSync(dest); } catch {}
-      
-      if (retryCount < MAX_RETRIES) {
-        console.log(`Download timeout, retrying in ${RETRY_DELAY/1000}s... (${retryCount + 1}/${MAX_RETRIES})`);
-        setTimeout(() => {
-          downloadBinary(url, dest, retryCount + 1)
-            .then(resolve)
-            .catch(reject);
-        }, RETRY_DELAY);
-        return;
-      }
-      
-      reject(new Error('Download timeout after multiple retries'));
-    });
-    
-    request.on('error', (err) => {
-      file.close();
-      try { fs.unlinkSync(dest); } catch {}
-      
-      if (retryCount < MAX_RETRIES) {
-        console.log(`Download error, retrying in ${RETRY_DELAY/1000}s... (${retryCount + 1}/${MAX_RETRIES})`);
-        setTimeout(() => {
-          downloadBinary(url, dest, retryCount + 1)
-            .then(resolve)
-            .catch(reject);
-        }, RETRY_DELAY);
-        return;
-      }
-      
-      reject(err);
-    });
-  });
+	return new Promise((resolve, reject) => {
+		const file = fs.createWriteStream(dest);
+		const protocol = url.startsWith("https") ? https : http;
+
+		const request = protocol.get(
+			url,
+			{ timeout: DOWNLOAD_TIMEOUT },
+			(response) => {
+				if (response.statusCode === 302 || response.statusCode === 301) {
+					file.close();
+					try {
+						fs.unlinkSync(dest);
+					} catch {}
+					downloadBinary(response.headers.location, dest, retryCount)
+						.then(resolve)
+						.catch(reject);
+					return;
+				}
+
+				if (response.statusCode !== 200) {
+					file.close();
+					try {
+						fs.unlinkSync(dest);
+					} catch {}
+					const error = new Error(
+						`HTTP ${response.statusCode}: ${response.statusMessage}`,
+					);
+
+					if (retryCount < MAX_RETRIES) {
+						console.log(
+							`Download failed, retrying in ${RETRY_DELAY / 1000}s... (${retryCount + 1}/${MAX_RETRIES})`,
+						);
+						setTimeout(() => {
+							downloadBinary(url, dest, retryCount + 1)
+								.then(resolve)
+								.catch(reject);
+						}, RETRY_DELAY);
+						return;
+					}
+
+					reject(error);
+					return;
+				}
+
+				let downloadedBytes = 0;
+				response.on("data", (chunk) => {
+					downloadedBytes += chunk.length;
+				});
+
+				response.pipe(file);
+
+				file.on("finish", () => {
+					file.close();
+					if (downloadedBytes === 0) {
+						try {
+							fs.unlinkSync(dest);
+						} catch {}
+						reject(new Error("Downloaded file is empty"));
+						return;
+					}
+					console.log(`Downloaded ${downloadedBytes} bytes`);
+					resolve();
+				});
+
+				file.on("error", (err) => {
+					file.close();
+					try {
+						fs.unlinkSync(dest);
+					} catch {}
+					reject(err);
+				});
+			},
+		);
+
+		request.on("timeout", () => {
+			request.destroy();
+			file.close();
+			try {
+				fs.unlinkSync(dest);
+			} catch {}
+
+			if (retryCount < MAX_RETRIES) {
+				console.log(
+					`Download timeout, retrying in ${RETRY_DELAY / 1000}s... (${retryCount + 1}/${MAX_RETRIES})`,
+				);
+				setTimeout(() => {
+					downloadBinary(url, dest, retryCount + 1)
+						.then(resolve)
+						.catch(reject);
+				}, RETRY_DELAY);
+				return;
+			}
+
+			reject(new Error("Download timeout after multiple retries"));
+		});
+
+		request.on("error", (err) => {
+			file.close();
+			try {
+				fs.unlinkSync(dest);
+			} catch {}
+
+			if (retryCount < MAX_RETRIES) {
+				console.log(
+					`Download error, retrying in ${RETRY_DELAY / 1000}s... (${retryCount + 1}/${MAX_RETRIES})`,
+				);
+				setTimeout(() => {
+					downloadBinary(url, dest, retryCount + 1)
+						.then(resolve)
+						.catch(reject);
+				}, RETRY_DELAY);
+				return;
+			}
+
+			reject(err);
+		});
+	});
 }
 
 async function extractArchive(archivePath, extractDir, platform) {
-  if (platform === 'windows') {
-    // Use safer PowerShell execution with proper escaping
-    const escapedArchivePath = archivePath.replace(/'/g, "''");
-    const escapedExtractDir = extractDir.replace(/'/g, "''");
-    
-    const powershellCommand = [
-      'powershell.exe',
-      '-NoProfile',
-      '-ExecutionPolicy', 'Bypass',
-      '-Command',
-      `Expand-Archive -LiteralPath '${escapedArchivePath}' -DestinationPath '${escapedExtractDir}' -Force`
-    ];
-    
-    await new Promise((resolve, reject) => {
-      const child = spawn(powershellCommand[0], powershellCommand.slice(1), {
-        stdio: ['pipe', 'pipe', 'pipe'],
-        windowsHide: true
-      });
-      
-      let stderr = '';
-      child.stderr.on('data', (data) => {
-        stderr += data.toString();
-      });
-      
-      child.on('close', (code) => {
-        if (code === 0) {
-          resolve();
-        } else {
-          reject(new Error(`PowerShell extraction failed with code ${code}: ${stderr}`));
-        }
-      });
-      
-      child.on('error', reject);
-    });
-  } else {
-    // Use spawn instead of exec for better security and error handling
-    await new Promise((resolve, reject) => {
-      const child = spawn('tar', ['-xzf', archivePath, '-C', extractDir], {
-        stdio: ['pipe', 'pipe', 'pipe']
-      });
-      
-      let stderr = '';
-      child.stderr.on('data', (data) => {
-        stderr += data.toString();
-      });
-      
-      child.on('close', (code) => {
-        if (code === 0) {
-          resolve();
-        } else {
-          reject(new Error(`tar extraction failed with code ${code}: ${stderr}`));
-        }
-      });
-      
-      child.on('error', reject);
-    });
-  }
+	if (platform === "windows") {
+		const escapedArchivePath = archivePath.replace(/'/g, "''");
+		const escapedExtractDir = extractDir.replace(/'/g, "''");
+
+		const powershellCommand = [
+			"powershell.exe",
+			"-NoProfile",
+			"-ExecutionPolicy",
+			"Bypass",
+			"-Command",
+			`Expand-Archive -LiteralPath '${escapedArchivePath}' -DestinationPath '${escapedExtractDir}' -Force`,
+		];
+
+		await new Promise((resolve, reject) => {
+			const child = spawn(powershellCommand[0], powershellCommand.slice(1), {
+				stdio: ["pipe", "pipe", "pipe"],
+				windowsHide: true,
+			});
+
+			let stderr = "";
+			child.stderr.on("data", (data) => {
+				stderr += data.toString();
+			});
+
+			child.on("close", (code) => {
+				if (code === 0) {
+					resolve();
+				} else {
+					reject(
+						new Error(
+							`PowerShell extraction failed with code ${code}: ${stderr}`,
+						),
+					);
+				}
+			});
+
+			child.on("error", reject);
+		});
+	} else {
+		await new Promise((resolve, reject) => {
+			const child = spawn("tar", ["-xzf", archivePath, "-C", extractDir], {
+				stdio: ["pipe", "pipe", "pipe"],
+			});
+
+			let stderr = "";
+			child.stderr.on("data", (data) => {
+				stderr += data.toString();
+			});
+
+			child.on("close", (code) => {
+				if (code === 0) {
+					resolve();
+				} else {
+					reject(
+						new Error(`tar extraction failed with code ${code}: ${stderr}`),
+					);
+				}
+			});
+
+			child.on("error", reject);
+		});
+	}
 }
 
 async function install() {
-  const DEBUG = process.env.AI_RULEZ_DEBUG === '1';
-  
-  try {
-    if (DEBUG) console.error('[install.js] Starting installation');
-    
-    // Check Node.js version compatibility
-    const nodeVersion = process.version;
-    const majorVersion = parseInt(nodeVersion.slice(1).split('.')[0]);
-    if (majorVersion < 20) {
-      console.error(`Error: Node.js ${nodeVersion} is not supported. Please upgrade to Node.js 20 or later.`);
-      process.exit(1);
-    }
-    
-    const { os, arch } = getPlatform();
-    const binaryName = getBinaryName(os);
-    
-    if (DEBUG) console.error(`[install.js] Platform: ${os}/${arch}, Binary name: ${binaryName}`);
-    
-    const packageJson = JSON.parse(fs.readFileSync(path.join(__dirname, 'package.json'), 'utf8'));
-    const version = packageJson.version;
-    
-    
-    const archiveExt = os === 'windows' ? 'zip' : 'tar.gz';
-    const archiveName = `ai-rulez_${version}_${os}_${arch}.${archiveExt}`;
-    const downloadUrl = `https://github.com/${REPO_NAME}/releases/download/v${version}/${archiveName}`;
-    const checksumUrl = `https://github.com/${REPO_NAME}/releases/download/v${version}/checksums.txt`;
-    
-    console.log(`Downloading ai-rulez ${version} for ${os}/${arch}...`);
-    console.log(`URL: ${downloadUrl}`);
-    
-    
-    const binDir = path.join(__dirname, 'bin');
-    if (!fs.existsSync(binDir)) {
-      fs.mkdirSync(binDir, { recursive: true });
-    }
-    
-    
-    const archivePath = path.join(__dirname, archiveName);
-    
-    // Download checksums first for verification
-    console.log('Downloading checksums...');
-    const checksumPath = path.join(__dirname, 'checksums.txt');
-    try {
-      await downloadBinary(checksumUrl, checksumPath);
-    } catch (checksumError) {
-      console.warn('Warning: Could not download checksums, skipping verification');
-    }
-    
-    await downloadBinary(downloadUrl, archivePath);
-    
-    // Verify checksum if available
-    if (fs.existsSync(checksumPath)) {
-      console.log('Verifying checksum...');
-      const expectedHash = await getExpectedChecksum(checksumPath, archiveName);
-      if (expectedHash) {
-        const actualHash = await calculateSHA256(archivePath);
-        if (actualHash !== expectedHash) {
-          throw new Error(`Checksum verification failed. Expected: ${expectedHash}, Got: ${actualHash}`);
-        }
-        console.log('✓ Checksum verified');
-      }
-      fs.unlinkSync(checksumPath);
-    }
-    
-    
-    console.log('Extracting binary...');
-    
-    // Extract to a temp directory first to avoid overwriting the wrapper script
-    const tempExtractDir = path.join(__dirname, '.extract-temp');
-    if (fs.existsSync(tempExtractDir)) {
-      fs.rmSync(tempExtractDir, { recursive: true, force: true });
-    }
-    fs.mkdirSync(tempExtractDir, { recursive: true });
-    
-    await extractArchive(archivePath, tempExtractDir, os);
-    
-    // The archive contains 'ai-rulez' or 'ai-rulez.exe', but we need to rename it
-    // to avoid conflict with the wrapper script
-    const extractedName = os === 'windows' ? 'ai-rulez.exe' : 'ai-rulez';
-    const extractedPath = path.join(tempExtractDir, extractedName);
-    const binaryPath = path.join(binDir, binaryName);
-    
-    // Move the extracted binary to the final location
-    if (fs.existsSync(extractedPath)) {
-      // Remove old binary if it exists
-      if (fs.existsSync(binaryPath)) {
-        fs.unlinkSync(binaryPath);
-      }
-      // Move binary from temp to final location
-      fs.renameSync(extractedPath, binaryPath);
-    }
-    
-    // Clean up temp directory
-    fs.rmSync(tempExtractDir, { recursive: true, force: true });
-    
-    if (!fs.existsSync(binaryPath)) {
-      throw new Error(`Binary not found after extraction: ${binaryPath}`);
-    }
-    
-    
-    if (os !== 'windows') {
-      fs.chmodSync(binaryPath, 0o755);
-    }
-    
-    // Verify binary is executable
-    try {
-      await new Promise((resolve, reject) => {
-        const testCommand = os === 'windows' ? [binaryPath, '--version'] : [binaryPath, '--version'];
-        const child = spawn(testCommand[0], testCommand.slice(1), {
-          stdio: ['pipe', 'pipe', 'pipe'],
-          timeout: 5000
-        });
-        
-        child.on('close', (code) => {
-          // Any exit code is fine, we just want to verify it can execute
-          resolve();
-        });
-        
-        child.on('error', (err) => {
-          if (err.code === 'ENOENT') {
-            reject(new Error('Downloaded binary is not executable'));
-          } else {
-            resolve(); // Other errors are OK for version check
-          }
-        });
-      });
-    } catch (verifyError) {
-      console.warn('Warning: Could not verify binary execution:', verifyError.message);
-    }
-    
-    
-    fs.unlinkSync(archivePath);
-    
-    console.log(`✅ ai-rulez ${version} installed successfully for ${os}/${arch}!`);
-    
-    if (DEBUG) {
-      console.error(`[install.js] Installation complete`);
-      console.error(`[install.js] Binary location: ${binaryPath}`);
-      console.error(`[install.js] Exiting with code 0`);
-    }
-    
-    // Explicitly exit with success code
-    process.exit(0);
-    
-  } catch (error) {
-    if (DEBUG) console.error(`[install.js] Installation failed: ${error.message}`);
-    console.error('Failed to install ai-rulez binary:', error.message);
-    console.error('You can manually download the binary from:');
-    console.error(`https://github.com/${REPO_NAME}/releases`);
-    process.exit(1);
-  }
-}
+	const DEBUG = process.env.AI_RULEZ_DEBUG === "1";
+
+	try {
+		if (DEBUG) console.error("[install.js] Starting installation");
+
+		const nodeVersion = process.version;
+		const majorVersion = parseInt(nodeVersion.slice(1).split(".")[0], 10);
+		if (majorVersion < 20) {
+			console.error(
+				`Error: Node.js ${nodeVersion} is not supported. Please upgrade to Node.js 20 or later.`,
+			);
+			process.exit(1);
+		}
+
+		const { os, arch } = getPlatform();
+		const binaryName = getBinaryName(os);
+
+		if (DEBUG)
+			console.error(
+				`[install.js] Platform: ${os}/${arch}, Binary name: ${binaryName}`,
+			);
+
+		const packageJson = JSON.parse(
+			fs.readFileSync(path.join(__dirname, "package.json"), "utf8"),
+		);
+		const version = packageJson.version;
+
+		const archiveExt = os === "windows" ? "zip" : "tar.gz";
+		const archiveName = `ai-rulez_${version}_${os}_${arch}.${archiveExt}`;
+		const downloadUrl = `https://github.com/${REPO_NAME}/releases/download/v${version}/${archiveName}`;
+		const checksumUrl = `https://github.com/${REPO_NAME}/releases/download/v${version}/checksums.txt`;
+
+		console.log(`Downloading ai-rulez ${version} for ${os}/${arch}...`);
+		console.log(`URL: ${downloadUrl}`);
+
+		const binDir = path.join(__dirname, "bin");
+		if (!fs.existsSync(binDir)) {
+			fs.mkdirSync(binDir, { recursive: true });
+		}
+
+		const archivePath = path.join(__dirname, archiveName);
+
+		console.log("Downloading checksums...");
+		const checksumPath = path.join(__dirname, "checksums.txt");
+		try {
+			await downloadBinary(checksumUrl, checksumPath);
+		} catch (_checksumError) {
+			console.warn(
+				"Warning: Could not download checksums, skipping verification",
+			);
+		}
+
+		await downloadBinary(downloadUrl, archivePath);
+
+		if (fs.existsSync(checksumPath)) {
+			console.log("Verifying checksum...");
+			const expectedHash = await getExpectedChecksum(checksumPath, archiveName);
+			if (expectedHash) {
+				const actualHash = await calculateSHA256(archivePath);
+				if (actualHash !== expectedHash) {
+					throw new Error(
+						`Checksum verification failed. Expected: ${expectedHash}, Got: ${actualHash}`,
+					);
+				}
+				console.log("✓ Checksum verified");
+			}
+			fs.unlinkSync(checksumPath);
+		}
+
+		console.log("Extracting binary...");
 
+		const tempExtractDir = path.join(__dirname, ".extract-temp");
+		if (fs.existsSync(tempExtractDir)) {
+			fs.rmSync(tempExtractDir, { recursive: true, force: true });
+		}
+		fs.mkdirSync(tempExtractDir, { recursive: true });
 
-// Export functions for testing
-if (typeof module !== 'undefined' && module.exports) {
-  module.exports = {
-    getPlatform,
-    getBinaryName,
-    downloadBinary,
-    extractArchive,
-    calculateSHA256,
-    getExpectedChecksum,
-    install
-  };
+		await extractArchive(archivePath, tempExtractDir, os);
+
+		const extractedName = os === "windows" ? "ai-rulez.exe" : "ai-rulez";
+		const extractedPath = path.join(tempExtractDir, extractedName);
+		const binaryPath = path.join(binDir, binaryName);
+
+		if (fs.existsSync(extractedPath)) {
+			if (fs.existsSync(binaryPath)) {
+				fs.unlinkSync(binaryPath);
+			}
+			fs.renameSync(extractedPath, binaryPath);
+		}
+
+		fs.rmSync(tempExtractDir, { recursive: true, force: true });
+
+		if (!fs.existsSync(binaryPath)) {
+			throw new Error(`Binary not found after extraction: ${binaryPath}`);
+		}
+
+		if (os !== "windows") {
+			fs.chmodSync(binaryPath, 0o755);
+		}
+
+		try {
+			await new Promise((resolve, reject) => {
+				const testCommand =
+					os === "windows"
+						? [binaryPath, "--version"]
+						: [binaryPath, "--version"];
+				const child = spawn(testCommand[0], testCommand.slice(1), {
+					stdio: ["pipe", "pipe", "pipe"],
+					timeout: 5000,
+				});
+
+				child.on("close", (_code) => {
+					resolve();
+				});
+
+				child.on("error", (err) => {
+					if (err.code === "ENOENT") {
+						reject(new Error("Downloaded binary is not executable"));
+					} else {
+						resolve();
+					}
+				});
+			});
+		} catch (verifyError) {
+			console.warn(
+				"Warning: Could not verify binary execution:",
+				verifyError.message,
+			);
+		}
+
+		fs.unlinkSync(archivePath);
+
+		console.log(
+			`✅ ai-rulez ${version} installed successfully for ${os}/${arch}!`,
+		);
+
+		if (DEBUG) {
+			console.error(`[install.js] Installation complete`);
+			console.error(`[install.js] Binary location: ${binaryPath}`);
+			console.error(`[install.js] Exiting with code 0`);
+		}
+
+		process.exit(0);
+	} catch (error) {
+		if (DEBUG)
+			console.error(`[install.js] Installation failed: ${error.message}`);
+		console.error("Failed to install ai-rulez binary:", error.message);
+		console.error("You can manually download the binary from:");
+		console.error(`https://github.com/${REPO_NAME}/releases`);
+		process.exit(1);
+	}
+}
+
+if (typeof module !== "undefined" && module.exports) {
+	module.exports = {
+		getPlatform,
+		getBinaryName,
+		downloadBinary,
+		extractArchive,
+		calculateSHA256,
+		getExpectedChecksum,
+		install,
+	};
 }
 
 if (require.main === module) {
-  install();
-}
+	install();
+}

package/package.json

@@ -1,73 +1,86 @@
 {
-  "name": "ai-rulez",
-  "version": "1.6.0",
-  "description": "⚡ Lightning-fast CLI tool (written in Go) for managing AI assistant rules - generate configuration files for Claude, Cursor, Windsurf and more",
-  "keywords": [
-    "ai",
-    "ai-assistant", 
-    "ai-rules",
-    "claude",
-    "cursor", 
-    "windsurf",
-    "codeium",
-    "copilot",
-    "cli",
-    "cli-tool",
-    "configuration",
-    "config",
-    "rules",
-    "generator",
-    "golang",
-    "go",
-    "fast",
-    "development",
-    "developer-tools",
-    "automation",
-    "workflow", 
-    "productivity",
-    "pre-commit",
-    "git-hooks",
-    "lefthook",
-    "code-generation",
-    "ai-development",
-    "assistant-configuration"
-  ],
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/Goldziher/ai-rulez.git"
-  },
-  "homepage": "https://github.com/Goldziher/ai-rulez#readme",
-  "bugs": {
-    "url": "https://github.com/Goldziher/ai-rulez/issues"
-  },
-  "license": "MIT",
-  "author": {
-    "name": "Na'aman Hirschfeld",
-    "email": "nhirschfeld@gmail.com",
-    "url": "https://github.com/Goldziher"
-  },
-  "bin": {
-    "ai-rulez": "./bin/ai-rulez"
-  },
-  "scripts": {
-    "postinstall": "node install.js"
-  },
-  "files": [
-    "bin",
-    "install.js", 
-    "README.md"
-  ],
-  "engines": {
-    "node": ">=14.0.0"
-  },
-  "os": [
-    "darwin",
-    "linux",
-    "win32"
-  ],
-  "cpu": [
-    "x64", 
-    "arm64",
-    "ia32"
-  ]
-}
+	"name": "ai-rulez",
+	"version": "2.0.0",
+	"description": "⚡ One config to rule them all. Centralized AI assistant configuration management - generate rules for Claude, Cursor, Copilot, Windsurf and more from a single YAML file.",
+	"keywords": [
+		"ai",
+		"ai-assistant",
+		"ai-rules",
+		"claude",
+		"cursor",
+		"copilot",
+		"windsurf",
+		"gemini",
+		"cline",
+		"continue-dev",
+		"mcp",
+		"model-context-protocol",
+		"cli",
+		"configuration",
+		"config",
+		"rules",
+		"generator",
+		"golang",
+		"go",
+		"development",
+		"developer-tools",
+		"automation",
+		"workflow",
+		"productivity",
+		"pre-commit",
+		"git-hooks",
+		"code-generation",
+		"ai-development",
+		"assistant-configuration",
+		"monorepo",
+		"presets",
+		"agents"
+	],
+	"repository": {
+		"type": "git",
+		"url": "https://github.com/Goldziher/ai-rulez.git"
+	},
+	"homepage": "https://goldziher.github.io/ai-rulez/",
+	"bugs": {
+		"url": "https://github.com/Goldziher/ai-rulez/issues"
+	},
+	"funding": {
+		"type": "github",
+		"url": "https://github.com/sponsors/Goldziher"
+	},
+	"license": "MIT",
+	"author": {
+		"name": "Na'aman Hirschfeld",
+		"email": "nhirschfeld@gmail.com",
+		"url": "https://github.com/Goldziher"
+	},
+	"maintainers": [
+		{
+			"name": "Na'aman Hirschfeld",
+			"email": "nhirschfeld@gmail.com",
+			"url": "https://github.com/Goldziher"
+		}
+	],
+	"bin": {
+		"ai-rulez": "./bin/ai-rulez.js"
+	},
+	"scripts": {},
+	"files": [
+		"bin/",
+		"install.js",
+		"../../README.md"
+	],
+	"engines": {
+		"node": ">=14.0.0"
+	},
+	"os": [
+		"darwin",
+		"linux",
+		"win32"
+	],
+	"cpu": [
+		"x64",
+		"arm64",
+		"ia32"
+	]
+}

package/README.md

@@ -1,261 +0,0 @@
-# ai-rulez ⚡
-
-> **Lightning-fast CLI tool (written in Go) for managing AI assistant rules**
-
-Generate configuration files for Claude, Cursor, Windsurf, and other AI assistants from a single, centralized configuration.
-
-## 🚀 Features
-
-- ⚡ **Blazing Fast**: Written in Go for maximum performance
-- 🔧 **Multi-Assistant Support**: Generate configs for Claude (CLAUDE.md), Cursor (.cursorrules), Windsurf (.windsurfrules), and more
-- 📝 **Single Source of Truth**: Maintain all your AI rules in one YAML configuration
-- 🎯 **Smart Templates**: Built-in templates with custom template support
-- 🔍 **Validation**: Comprehensive configuration validation
-- 🔄 **Git Integration**: Perfect for pre-commit hooks and CI/CD
-- 📦 **Node.js Integration**: Easy installation via npm
-
-## 📦 Installation
-
-### npm (Recommended)
-
-```bash
-# Global installation
-npm install -g ai-rulez
-
-# Local project installation
-npm install --save-dev ai-rulez
-```
-
-The npm package automatically downloads and manages the Go binary for your platform.
-
-### Other Installation Methods
-
-- **pip**: `pip install ai-rulez`
-- **Go**: `go install github.com/Goldziher/ai-rulez@latest`
-- **Homebrew**: `brew install goldziher/tap/ai-rulez` *(coming soon)*
-- **Direct Download**: Download from [GitHub Releases](https://github.com/Goldziher/ai-rulez/releases)
-
-## 🎯 Quick Start
-
-1. **Create a configuration file** (`ai-rulez.yaml`):
-
-```yaml
-metadata:
-  name: "My AI Rules"
-  version: "1.0.0"
-
-rules:
-  - name: "Code Style"
-    priority: 10
-    content: |
-      - Use TypeScript strict mode
-      - Prefer functional components
-      - Use meaningful variable names
-
-  - name: "Testing"
-    priority: 5
-    content: |
-      - Write unit tests for all functions
-      - Use describe/it pattern
-      - Aim for 80% code coverage
-
-outputs:
-  - file: "CLAUDE.md"
-    template: "claude"
-  - file: ".cursorrules"
-    template: "cursor"
-  - file: ".windsurfrules" 
-    template: "windsurf"
-```
-
-2. **Generate configuration files**:
-
-```bash
-ai-rulez generate
-```
-
-This creates `CLAUDE.md`, `.cursorrules`, and `.windsurfrules` with your rules properly formatted for each AI assistant.
-
-## 🛠️ Commands
-
-```bash
-# Generate all configuration files
-ai-rulez generate
-
-# Validate configuration
-ai-rulez validate
-
-# Generate recursively in subdirectories
-ai-rulez generate --recursive
-
-# Preview output without writing files
-ai-rulez generate --dry-run
-
-# Show help
-ai-rulez --help
-```
-
-## 🔄 Git Integration
-
-### Pre-commit Hook
-
-Add to your `.pre-commit-config.yaml`:
-
-```yaml
-repos:
-  - repo: https://github.com/Goldziher/ai-rulez
-    rev: v1.0.0
-    hooks:
-      - id: ai-rulez-generate
-```
-
-### Lefthook
-
-Add to your `lefthook.yml`:
-
-```yaml
-pre-commit:
-  commands:
-    ai-rulez:
-      run: ai-rulez generate
-      files: git diff --cached --name-only
-      glob: "*.{ai-rulez,ai_rulez}.{yml,yaml}"
-```
-
-### npm Scripts
-
-Add to your `package.json`:
-
-```json
-{
-  "scripts": {
-    "ai-rulez": "ai-rulez generate",
-    "ai-rulez:validate": "ai-rulez validate",
-    "ai-rulez:watch": "ai-rulez generate --recursive"
-  }
-}
-```
-
-## 📚 Configuration
-
-The tool looks for configuration files in this order:
-- `.ai-rulez.yaml`
-- `ai-rulez.yaml` 
-- `.ai_rulez.yaml`
-- `ai_rulez.yaml`
-
-### User Rules vs. Coding Rules
-
-When creating AI rules, distinguish between two types of instructions:
-
-- **Coding Rules**: Technical guidelines about code quality, architecture, testing, etc.
-  - Examples: "Use TypeScript strict mode", "Write unit tests", "Follow REST conventions"
-  - Should be in the main configuration file committed to version control
-
-- **User Rules**: Personal preferences about communication style and interaction
-  - Examples: "Be concise in responses", "Use casual tone", "Address me as 'Chief'", "Always explain your reasoning"
-  - Perfect for `.local.yaml` files (e.g., `ai-rulez.local.yaml`) as they're personal and shouldn't affect the whole team
-  - Allow individual developers to customize AI behavior without impacting others
-
-**Example local config** (`ai-rulez.local.yaml`):
-```yaml
-rules:
-  - name: "Communication Style"
-    content: "Be concise and direct. Address me as 'Boss'. Always ask for clarification before making assumptions."
-  - name: "Response Format"
-    content: "Provide code examples for every suggestion. Use bullet points for lists."
-```
-
-### Configuration Schema
-
-```yaml
-metadata:
-  name: string          # Required: Project name
-  version: string       # Required: Version
-  description: string   # Optional: Description
-
-rules:
-  - name: string        # Required: Rule name
-    priority: number    # Required: Priority (1-10)
-    content: string     # Required: Rule content
-
-sections:              # Optional: Organize rules into sections
-  - title: string      # Required: Section title
-    priority: number   # Required: Section priority
-    content: string    # Required: Section content
-
-outputs:               # Required: At least one output
-  - file: string       # Required: Output filename
-    template: string   # Required: Template name or path
-
-includes:              # Optional: Include other config files
-  - path/to/other.yaml
-```
-
-## 🎨 Templates
-
-Built-in templates:
-- `claude` - CLAUDE.md format
-- `cursor` - .cursorrules format  
-- `windsurf` - .windsurfrules format
-- `default` - Generic format
-
-Custom templates use Go template syntax with access to `.Rules`, `.Sections`, `.Metadata`, etc.
-
-## 🔧 Advanced Usage
-
-### Environment Variables
-
-- `AI_RULEZ_CONFIG` - Override config file path
-- `AI_RULEZ_DEBUG` - Enable debug output
-
-### Node.js API
-
-```javascript
-const { execSync } = require('child_process');
-
-// Run ai-rulez programmatically
-try {
-  const output = execSync('ai-rulez generate --dry-run', { encoding: 'utf8' });
-  console.log(output);
-} catch (error) {
-  console.error('ai-rulez failed:', error.message);
-}
-```
-
-### npm Scripts Integration
-
-```json
-{
-  "scripts": {
-    "precommit": "ai-rulez generate",
-    "lint": "eslint . && ai-rulez validate",
-    "build": "npm run ai-rulez && npm run compile"
-  },
-  "husky": {
-    "hooks": {
-      "pre-commit": "ai-rulez generate"
-    }
-  }
-}
-```
-
-## 🤝 Contributing
-
-Contributions are welcome! Please see our [Contributing Guide](https://github.com/Goldziher/ai-rulez/blob/main/CONTRIBUTING.md).
-
-## 📄 License
-
-MIT License - see [LICENSE](https://github.com/Goldziher/ai-rulez/blob/main/LICENSE)
-
-## 🔗 Links
-
-- [GitHub Repository](https://github.com/Goldziher/ai-rulez)
-- [Documentation](https://github.com/Goldziher/ai-rulez#readme)
-- [Issues](https://github.com/Goldziher/ai-rulez/issues)
-- [Releases](https://github.com/Goldziher/ai-rulez/releases)
-- [PyPI Package](https://pypi.org/project/ai-rulez/)
-
----
-
-**Note**: This npm package is a wrapper around the Go binary. The actual tool is written in Go for maximum performance and cross-platform compatibility.