@hona/ralph-cli 0.1.0

package/bin/ralph

@@ -0,0 +1,134 @@
+#!/usr/bin/env node
+/**
+ * Ralph CLI Launcher
+ *
+ * This is a thin JavaScript wrapper that finds and executes the correct
+ * platform-specific binary for the current OS/architecture.
+ *
+ * The binary is located in one of the optional dependency packages:
+ *   - ralph-opencode-darwin-arm64
+ *   - ralph-opencode-darwin-x64
+ *   - ralph-opencode-linux-arm64
+ *   - ralph-opencode-linux-x64
+ *   - ralph-opencode-windows-x64
+ *
+ * Environment variables:
+ *   RALPH_BIN_PATH - Override path to the ralph binary
+ */
+
+const childProcess = require("child_process");
+const fs = require("fs");
+const path = require("path");
+const os = require("os");
+
+/**
+ * Run the binary with inherited stdio
+ */
+function run(target) {
+  const result = childProcess.spawnSync(target, process.argv.slice(2), {
+    stdio: "inherit",
+  });
+
+  if (result.error) {
+    console.error(result.error.message);
+    process.exit(1);
+  }
+
+  const code = typeof result.status === "number" ? result.status : 0;
+  process.exit(code);
+}
+
+// Check for environment variable override
+const envPath = process.env.RALPH_BIN_PATH;
+if (envPath) {
+  run(envPath);
+}
+
+// Get the real path of this script (resolves symlinks)
+const scriptPath = fs.realpathSync(__filename);
+const scriptDir = path.dirname(scriptPath);
+
+// Map OS and architecture to package naming conventions
+const platformMap = {
+  darwin: "darwin",
+  linux: "linux",
+  win32: "windows",
+};
+
+const archMap = {
+  x64: "x64",
+  arm64: "arm64",
+};
+
+let platform = platformMap[os.platform()];
+if (!platform) {
+  platform = os.platform();
+}
+
+let arch = archMap[os.arch()];
+if (!arch) {
+  arch = os.arch();
+}
+
+// Construct package and binary names
+const packageBase = "@hona/ralph-cli-" + platform + "-" + arch;
+const binaryName = platform === "windows" ? "ralph.exe" : "ralph";
+
+/**
+ * Search for the binary in node_modules hierarchy
+ */
+function findBinary(startDir) {
+  let current = startDir;
+
+  for (;;) {
+    const modules = path.join(current, "node_modules");
+
+    if (fs.existsSync(modules)) {
+      const entries = fs.readdirSync(modules);
+
+      for (const entry of entries) {
+        // Match package name (could have version suffix in some package managers)
+        if (!entry.startsWith(packageBase)) {
+          continue;
+        }
+
+        const candidate = path.join(modules, entry, "bin", binaryName);
+        if (fs.existsSync(candidate)) {
+          return candidate;
+        }
+      }
+    }
+
+    // Move up to parent directory
+    const parent = path.dirname(current);
+    if (parent === current) {
+      // Reached filesystem root
+      return;
+    }
+    current = parent;
+  }
+}
+
+// Try to find the binary
+const resolved = findBinary(scriptDir);
+
+if (!resolved) {
+  console.error(
+    "Error: Could not find the ralph binary for your platform.\n\n" +
+      "It seems that your package manager failed to install the correct version\n" +
+      "of the ralph CLI for your platform (" +
+      platform +
+      "-" +
+      arch +
+      ").\n\n" +
+      'You can try manually installing the "' +
+      packageBase +
+      '" package:\n\n' +
+      "  npm install " +
+      packageBase +
+      "\n"
+  );
+  process.exit(1);
+}
+
+run(resolved);

package/package.json

@@ -0,0 +1,29 @@
+{
+  "name": "@hona/ralph-cli",
+  "version": "0.1.0",
+  "description": "Ralph - AI coding assistant CLI",
+  "bin": {
+    "ralph": "./bin/ralph"
+  },
+  "scripts": {
+    "postinstall": "node ./postinstall.mjs"
+  },
+  "optionalDependencies": {
+    "@hona/ralph-cli-darwin-arm64": "0.1.0",
+    "@hona/ralph-cli-darwin-x64": "0.1.0",
+    "@hona/ralph-cli-linux-arm64": "0.1.0",
+    "@hona/ralph-cli-linux-x64": "0.1.0",
+    "@hona/ralph-cli-windows-x64": "0.1.0"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/hona/opencode-ralph.git"
+  },
+  "keywords": [
+    "cli",
+    "ai",
+    "coding",
+    "assistant"
+  ],
+  "license": "MIT"
+}

package/postinstall.mjs

@@ -0,0 +1,145 @@
+#!/usr/bin/env node
+/**
+ * Postinstall script for ralph-opencode
+ *
+ * This script runs after `npm install ralph-opencode` and symlinks the
+ * platform-specific binary to the bin directory.
+ *
+ * On Windows, npm handles the .exe directly so we skip symlinking.
+ */
+
+import fs from "fs";
+import path from "path";
+import os from "os";
+import { fileURLToPath } from "url";
+import { createRequire } from "module";
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const require = createRequire(import.meta.url);
+
+/**
+ * Detect the current platform and architecture
+ */
+function detectPlatformAndArch() {
+  let platform;
+  switch (os.platform()) {
+    case "darwin":
+      platform = "darwin";
+      break;
+    case "linux":
+      platform = "linux";
+      break;
+    case "win32":
+      platform = "windows";
+      break;
+    default:
+      platform = os.platform();
+      break;
+  }
+
+  let arch;
+  switch (os.arch()) {
+    case "x64":
+      arch = "x64";
+      break;
+    case "arm64":
+      arch = "arm64";
+      break;
+    default:
+      arch = os.arch();
+      break;
+  }
+
+  return { platform, arch };
+}
+
+/**
+ * Find the platform-specific binary package
+ */
+function findBinary() {
+  const { platform, arch } = detectPlatformAndArch();
+  const packageName = `@hona/ralph-cli-${platform}-${arch}`;
+  const binaryName = platform === "windows" ? "ralph.exe" : "ralph";
+
+  try {
+    // Use require.resolve to find the package
+    const packageJsonPath = require.resolve(`${packageName}/package.json`);
+    const packageDir = path.dirname(packageJsonPath);
+    const binaryPath = path.join(packageDir, "bin", binaryName);
+
+    if (!fs.existsSync(binaryPath)) {
+      throw new Error(`Binary not found at ${binaryPath}`);
+    }
+
+    return { binaryPath, binaryName, packageName };
+  } catch (error) {
+    throw new Error(`Could not find package ${packageName}: ${error.message}`);
+  }
+}
+
+/**
+ * Prepare the bin directory and return paths
+ */
+function prepareBinDirectory(binaryName) {
+  const binDir = path.join(__dirname, "bin");
+  const targetPath = path.join(binDir, binaryName);
+
+  // Ensure bin directory exists
+  if (!fs.existsSync(binDir)) {
+    fs.mkdirSync(binDir, { recursive: true });
+  }
+
+  // Remove existing binary/symlink if it exists
+  if (fs.existsSync(targetPath)) {
+    fs.unlinkSync(targetPath);
+  }
+
+  return { binDir, targetPath };
+}
+
+/**
+ * Create symlink to the platform binary
+ */
+function symlinkBinary(sourcePath, binaryName) {
+  const { targetPath } = prepareBinDirectory(binaryName);
+
+  fs.symlinkSync(sourcePath, targetPath);
+  console.log(`ralph binary symlinked: ${targetPath} -> ${sourcePath}`);
+
+  // Verify the file exists after operation
+  if (!fs.existsSync(targetPath)) {
+    throw new Error(`Failed to symlink binary to ${targetPath}`);
+  }
+}
+
+/**
+ * Main function
+ */
+async function main() {
+  try {
+    // On Windows, npm handles the .exe directly via the bin field
+    // No postinstall symlinking needed
+    if (os.platform() === "win32") {
+      console.log(
+        "Windows detected: binary setup not needed (using packaged .exe)"
+      );
+      return;
+    }
+
+    const { binaryPath, binaryName, packageName } = findBinary();
+    console.log(`Found ${packageName} at ${binaryPath}`);
+    symlinkBinary(binaryPath, binaryName);
+  } catch (error) {
+    console.error("Failed to setup ralph binary:", error.message);
+    // Don't fail the install - the JS launcher will handle finding the binary
+    process.exit(0);
+  }
+}
+
+try {
+  main();
+} catch (error) {
+  console.error("Postinstall script error:", error.message);
+  // Exit gracefully - don't break npm install
+  process.exit(0);
+}