@wiggumdev/ralph-ai 0.0.2

package/bin/ralph

@@ -0,0 +1,91 @@
+#!/usr/bin/env node
+
+const childProcess = require("node:child_process");
+const fs = require("node:fs");
+const path = require("node:path");
+const os = require("node:os");
+
+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);
+}
+
+const envPath = process.env.OPENCODE_BIN_PATH;
+if (envPath) {
+  run(envPath);
+}
+
+const scriptPath = fs.realpathSync(__filename);
+const scriptDir = path.dirname(scriptPath);
+
+const NPM_SCOPE = "@wiggumdev";
+
+const platformMap = {
+  darwin: "darwin",
+  linux: "linux",
+  win32: "windows",
+};
+const archMap = {
+  x64: "x64",
+  arm64: "arm64",
+  arm: "arm",
+};
+
+let platform = platformMap[os.platform()];
+if (!platform) {
+  platform = os.platform();
+}
+let arch = archMap[os.arch()];
+if (!arch) {
+  arch = os.arch();
+}
+const base = `ralph-${platform}-${arch}`;
+const scopedBase = `${NPM_SCOPE}/${base}`;
+const binary = platform === "windows" ? "ralph.exe" : "ralph";
+
+function findBinary(startDir) {
+  let current = startDir;
+  for (;;) {
+    const modules = path.join(current, "node_modules");
+    if (fs.existsSync(modules)) {
+      // Check for scoped package in @wiggumdev directory
+      const scopedDir = path.join(modules, NPM_SCOPE);
+      if (fs.existsSync(scopedDir)) {
+        const entries = fs.readdirSync(scopedDir);
+        for (const entry of entries) {
+          if (!entry.startsWith(base)) {
+            continue;
+          }
+          const candidate = path.join(scopedDir, entry, "bin", binary);
+          if (fs.existsSync(candidate)) {
+            return candidate;
+          }
+        }
+      }
+    }
+    const parent = path.dirname(current);
+    if (parent === current) {
+      return;
+    }
+    current = parent;
+  }
+}
+
+const resolved = findBinary(scriptDir);
+if (!resolved) {
+  console.error(
+    'It seems that your package manager failed to install the right version of the ralph CLI for your platform. You can try manually installing the "' +
+      scopedBase +
+      '" package'
+  );
+  process.exit(1);
+}
+
+run(resolved);

package/package.json

@@ -0,0 +1,35 @@
+{
+  "name": "@wiggumdev/ralph-ai",
+  "version": "0.0.2",
+  "description": "AI-agnostic agentic loop CLI",
+  "bin": {
+    "ralph": "./bin/ralph"
+  },
+  "scripts": {
+    "postinstall": "node ./postinstall.mjs"
+  },
+  "optionalDependencies": {
+    "@wiggumdev/ralph-linux-arm64": "0.0.2",
+    "@wiggumdev/ralph-linux-x64": "0.0.2",
+    "@wiggumdev/ralph-linux-x64-baseline": "0.0.2",
+    "@wiggumdev/ralph-linux-arm64-musl": "0.0.2",
+    "@wiggumdev/ralph-linux-x64-musl": "0.0.2",
+    "@wiggumdev/ralph-linux-x64-baseline-musl": "0.0.2",
+    "@wiggumdev/ralph-darwin-arm64": "0.0.2",
+    "@wiggumdev/ralph-darwin-x64": "0.0.2",
+    "@wiggumdev/ralph-darwin-x64-baseline": "0.0.2",
+    "@wiggumdev/ralph-windows-x64": "0.0.2",
+    "@wiggumdev/ralph-windows-x64-baseline": "0.0.2"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/wiggumdev/ralph.git"
+  },
+  "license": "MIT",
+  "engines": {
+    "node": ">=18"
+  }
+}

package/postinstall.mjs

@@ -0,0 +1,125 @@
+#!/usr/bin/env node
+
+import fs from "node:fs";
+import { createRequire } from "node:module";
+import os from "node:os";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const require = createRequire(import.meta.url);
+
+// npm scope for scoped package names
+const NPM_SCOPE = "@wiggumdev";
+
+function detectPlatformAndArch() {
+  // Map platform names
+  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;
+  }
+
+  // Map architecture names
+  let arch;
+  switch (os.arch()) {
+    case "x64":
+      arch = "x64";
+      break;
+    case "arm64":
+      arch = "arm64";
+      break;
+    case "arm":
+      arch = "arm";
+      break;
+    default:
+      arch = os.arch();
+      break;
+  }
+
+  return { platform, arch };
+}
+
+function findBinary() {
+  const { platform, arch } = detectPlatformAndArch();
+  const packageName = `${NPM_SCOPE}/ralph-${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 };
+  } catch (error) {
+    throw new Error(`Could not find package ${packageName}: ${error.message}`);
+  }
+}
+
+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 };
+}
+
+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}`);
+  }
+}
+
+async function main() {
+  try {
+    if (os.platform() === "win32") {
+      // On Windows, the .exe is already included in the package and bin field points to it
+      // No postinstall setup needed
+      console.log(
+        "Windows detected: binary setup not needed (using packaged .exe)"
+      );
+      return;
+    }
+
+    const { binaryPath, binaryName } = findBinary();
+    symlinkBinary(binaryPath, binaryName);
+  } catch (error) {
+    console.error("Failed to setup ralph binary:", error.message);
+    process.exit(1);
+  }
+}
+
+main().catch((error) => {
+  console.error("Postinstall script error:", error.message);
+  process.exit(1);
+});