wolverine-ai 6.2.1 → 6.2.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wolverine-ai",
-  "version": "6.2.1",
+  "version": "6.2.3",
   "description": "Self-healing Node.js server framework powered by AI. Catches crashes, diagnoses errors, generates fixes, verifies, and restarts — automatically.",
   "main": "src/index.js",
   "bin": {

package/src/claw/setup.js

@@ -247,19 +247,41 @@ function detectWolverine(cwd) {
     brainExists: fs.existsSync(path.join(cwd, ".wolverine", "brain")),
   };
 
+  // Check if we're inside the wolverine repo itself
   try {
     const pkg = JSON.parse(fs.readFileSync(path.join(cwd, "package.json"), "utf-8"));
-    if (pkg.name === "wolverine-ai" || pkg.dependencies?.["wolverine-ai"]) {
+    if (pkg.name === "wolverine-ai") {
       result.installed = true;
-      result.version = pkg.version || pkg.dependencies?.["wolverine-ai"];
+      result.version = pkg.version;
+      return result;
     }
-    // Also check if we're inside the wolverine repo itself
-    if (fs.existsSync(path.join(cwd, "src", "core", "wolverine.js"))) {
+    // Check if wolverine-ai is a dependency
+    const deps = { ...pkg.dependencies, ...pkg.devDependencies, ...pkg.optionalDependencies };
+    if (deps["wolverine-ai"]) {
       result.installed = true;
-      result.version = pkg.version;
+      result.version = deps["wolverine-ai"];
     }
   } catch {}
 
+  // Check if wolverine.js exists in src/ (repo checkout)
+  if (fs.existsSync(path.join(cwd, "src", "core", "wolverine.js"))) {
+    result.installed = true;
+    try {
+      const pkg = JSON.parse(fs.readFileSync(path.join(cwd, "package.json"), "utf-8"));
+      result.version = pkg.version;
+    } catch {}
+  }
+
+  // Check node_modules
+  if (!result.installed) {
+    try {
+      const pkgPath = require.resolve("wolverine-ai/package.json", { paths: [cwd] });
+      const pkg = JSON.parse(fs.readFileSync(pkgPath, "utf-8"));
+      result.installed = true;
+      result.version = pkg.version;
+    } catch {}
+  }
+
   return result;
 }
 
@@ -325,13 +347,48 @@ function mergeConfig(openclawConfig, defaults) {
 
 // ── Scaffolding ─────────────────────────────────────────────────
 
+/**
+ * Find the wolverine-ai template directory.
+ * Works whether wolverine is the project root OR installed in node_modules.
+ */
+function _findTemplateDir() {
+  // 1. Relative to this file (we're in src/claw/setup.js → ../../wolverine-claw/)
+  const fromSrc = path.join(__dirname, "..", "..", "wolverine-claw");
+  if (fs.existsSync(path.join(fromSrc, "index.js"))) return fromSrc;
+
+  // 2. Via require.resolve (works when wolverine-ai is a node_modules dep)
+  try {
+    const pkgPath = require.resolve("wolverine-ai/package.json");
+    const pkgDir = path.dirname(pkgPath);
+    const fromPkg = path.join(pkgDir, "wolverine-claw");
+    if (fs.existsSync(path.join(fromPkg, "index.js"))) return fromPkg;
+  } catch {}
+
+  // 3. Check common node_modules locations
+  const candidates = [
+    path.join(process.cwd(), "node_modules", "wolverine-ai", "wolverine-claw"),
+    path.join(os.homedir(), "node_modules", "wolverine-ai", "wolverine-claw"),
+  ];
+  for (const c of candidates) {
+    if (fs.existsSync(path.join(c, "index.js"))) return c;
+  }
+
+  return null;
+}
+
 /**
  * Scaffold the wolverine-claw directory from template + merged config.
  */
 function scaffold(cwd, mergedConfig, env) {
   const clawDir = path.join(cwd, "wolverine-claw");
+  const templateDir = _findTemplateDir();
   const results = { created: [], skipped: [], errors: [] };
 
+  if (!templateDir) {
+    results.errors.push("Could not find wolverine-ai templates. Is wolverine-ai installed?");
+    return results;
+  }
+
   // Create directories
   const dirs = ["config", "plugins", "workspace", "skills"];
   for (const d of dirs) {
@@ -352,12 +409,11 @@ function scaffold(cwd, mergedConfig, env) {
   }
 
   // Copy index.js from template
-  const indexSrc = path.join(cwd, "wolverine-claw", "index.js");
-  if (!fs.existsSync(indexSrc)) {
-    // Copy from our built-in template
-    const templateIndex = path.join(__dirname, "..", "..", "wolverine-claw", "index.js");
-    if (fs.existsSync(templateIndex)) {
-      fs.copyFileSync(templateIndex, indexSrc);
+  const indexDest = path.join(clawDir, "index.js");
+  if (!fs.existsSync(indexDest)) {
+    const indexSrc = path.join(templateDir, "index.js");
+    if (fs.existsSync(indexSrc)) {
+      fs.copyFileSync(indexSrc, indexDest);
       results.created.push("index.js");
     }
   } else {
@@ -367,15 +423,10 @@ function scaffold(cwd, mergedConfig, env) {
   // Copy plugin
   const pluginDest = path.join(clawDir, "plugins", "wolverine-integration.js");
   if (!fs.existsSync(pluginDest)) {
-    const pluginSrc = path.join(cwd, "wolverine-claw", "plugins", "wolverine-integration.js");
+    const pluginSrc = path.join(templateDir, "plugins", "wolverine-integration.js");
     if (fs.existsSync(pluginSrc)) {
-      results.skipped.push("plugins/wolverine-integration.js (already exists at source)");
-    } else {
-      const templatePlugin = path.join(__dirname, "..", "..", "wolverine-claw", "plugins", "wolverine-integration.js");
-      if (fs.existsSync(templatePlugin)) {
-        fs.copyFileSync(templatePlugin, pluginDest);
-        results.created.push("plugins/wolverine-integration.js");
-      }
+      fs.copyFileSync(pluginSrc, pluginDest);
+      results.created.push("plugins/wolverine-integration.js");
     }
   } else {
     results.skipped.push("plugins/wolverine-integration.js (already exists)");
@@ -471,6 +522,79 @@ function ensureEnvFile(cwd, env) {
   return result;
 }
 
+/**
+ * Ensure wolverine-ai is installed as a dependency.
+ * Skips if we're running from the wolverine repo itself.
+ */
+function ensureWolverineDep(cwd) {
+  // If we're inside the wolverine repo, skip
+  const pkgPath = path.join(cwd, "package.json");
+  try {
+    const pkg = JSON.parse(fs.readFileSync(pkgPath, "utf-8"));
+    if (pkg.name === "wolverine-ai") {
+      return { installed: true, isRepo: true, alreadyPresent: true };
+    }
+    // Already a dependency?
+    const deps = { ...pkg.dependencies, ...pkg.devDependencies };
+    if (deps["wolverine-ai"]) {
+      return { installed: true, alreadyPresent: true };
+    }
+  } catch {}
+
+  // Install it
+  if (!fs.existsSync(pkgPath)) {
+    return { installed: false, reason: "no package.json" };
+  }
+
+  try {
+    console.log(chalk.gray("  Installing wolverine-ai..."));
+    execSync("npm install wolverine-ai@latest 2>&1", {
+      cwd,
+      encoding: "utf-8",
+      timeout: 120000,
+      stdio: ["pipe", "pipe", "pipe"],
+    });
+    return { installed: true, alreadyPresent: false };
+  } catch (err) {
+    return { installed: false, reason: `npm install failed: ${err.message?.split("\n")[0]}` };
+  }
+}
+
+/**
+ * Add claw-related npm scripts to the user's package.json.
+ */
+function addClawScripts(cwd) {
+  const pkgPath = path.join(cwd, "package.json");
+  if (!fs.existsSync(pkgPath)) return { added: 0 };
+
+  try {
+    const pkg = JSON.parse(fs.readFileSync(pkgPath, "utf-8"));
+    if (!pkg.scripts) pkg.scripts = {};
+
+    const toAdd = {
+      "claw": "wolverine-claw",
+      "claw:direct": "wolverine-claw --direct",
+      "claw:info": "wolverine-claw --info",
+    };
+
+    let added = 0;
+    for (const [name, cmd] of Object.entries(toAdd)) {
+      if (!pkg.scripts[name]) {
+        pkg.scripts[name] = cmd;
+        added++;
+      }
+    }
+
+    if (added > 0) {
+      fs.writeFileSync(pkgPath, JSON.stringify(pkg, null, 2) + "\n");
+    }
+
+    return { added, skipped: added === 0 };
+  } catch {
+    return { added: 0 };
+  }
+}
+
 /**
  * Ensure openclaw is installed as a dependency.
  */
@@ -730,9 +854,21 @@ async function setup(cwd, options = {}) {
 
   log("");
 
-  // ── Step 6: Install OpenClaw ────────────────────────────────
+  // ── Step 6: Install dependencies ─────────────────────────────
+  log(chalk.bold("  Dependencies...\n"));
+
+  // 6a: Install wolverine-ai itself if not already a dep
+  const wolverineDepResult = ensureWolverineDep(cwd);
+  if (wolverineDepResult.installed) {
+    log(chalk.green(`  ✅ wolverine-ai ${wolverineDepResult.alreadyPresent ? "already installed" : "installed"}`));
+  } else if (wolverineDepResult.isRepo) {
+    log(chalk.gray("  ○ wolverine-ai (running from repo)"));
+  } else {
+    log(chalk.yellow(`  ⚠️  wolverine-ai: ${wolverineDepResult.reason}`));
+  }
+
+  // 6b: Install openclaw if not already present
   if (!env.openclaw.localInstall) {
-    log(chalk.bold("  Dependencies...\n"));
     const depResult = ensureOpenClawDep(cwd);
     if (depResult.installed) {
       log(chalk.green(`  ✅ openclaw ${depResult.alreadyPresent ? "already installed" : "installed"}`));
@@ -742,9 +878,18 @@ async function setup(cwd, options = {}) {
         log(chalk.gray(`     ${depResult.fallback}`));
       }
     }
-    log("");
   }
 
+  // 6c: Add claw npm scripts to user's package.json
+  const scriptsResult = addClawScripts(cwd);
+  if (scriptsResult.added > 0) {
+    log(chalk.green(`  ✅ Added ${scriptsResult.added} npm scripts (claw, claw:info, claw:direct)`));
+  } else if (scriptsResult.skipped) {
+    log(chalk.gray("  ○ npm scripts already present"));
+  }
+
+  log("");
+
   // ── Step 7: Validate ───────────────────────────────────────
   log(chalk.bold("  Validating...\n"));
 
@@ -873,4 +1018,6 @@ module.exports = {
   validate,
   ensureEnvFile,
   ensureOpenClawDep,
+  ensureWolverineDep,
+  addClawScripts,
 };