robot-resources 1.10.6 → 1.11.0

package/bin/setup.js

@@ -3,9 +3,18 @@
 import { runWizard } from '../lib/wizard.js';
 
 const args = process.argv.slice(2);
-const nonInteractive = args.includes('--non-interactive') || args.includes('--yes') || args.includes('-y');
+const explicitNonInteractive =
+  args.includes('--non-interactive') || args.includes('--yes') || args.includes('-y');
+const targetArg = args.find((a) => a.startsWith('--for='));
+const target = targetArg ? targetArg.slice('--for='.length) : null;
 
-runWizard({ nonInteractive }).catch((err) => {
+// Treat piped/CI runs (no TTY on stdin OR stdout) as non-interactive so the
+// wizard never blocks on a prompt that can't be answered. The interactive
+// menu is only opened when both stdin and stdout are real terminals.
+const hasTty = Boolean(process.stdin.isTTY && process.stdout.isTTY);
+const nonInteractive = explicitNonInteractive || !hasTty;
+
+runWizard({ nonInteractive, target }).catch((err) => {
   console.error(`\n  ✗ Setup failed: ${err.message}\n`);
   process.exit(1);
 });

package/lib/non-oc-wizard.js

@@ -0,0 +1,238 @@
+import { existsSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { select } from '@inquirer/prompts';
+import { isClaudeCodeInstalled, isCursorInstalled } from './detect.js';
+import { configureClaudeCode, configureCursor } from './tool-config.js';
+import { header, info, success, warn, blank } from './ui.js';
+import { readConfig } from './config.mjs';
+
+const PLATFORM_URL = process.env.RR_PLATFORM_URL || 'https://api.robotresources.ai';
+
+const PATH_LABELS = {
+  js: 'JS/TS agent (LangChain, LangGraph, Mastra, etc.)',
+  python: 'Python agent (LangChain, LlamaIndex, CrewAI, etc.)',
+  mcp: 'Cursor / Claude Code / other MCP tool',
+  docs: "Just point me at docs, I'll integrate manually",
+  'install-oc': 'Install OpenClaw first — exit',
+};
+
+const VALID_TARGETS = new Set(Object.keys(PATH_LABELS).concat(['langchain', 'claude-code']));
+
+/**
+ * Inspect cwd to guess what the user is building. Returns one of the path
+ * keys, or null if we can't tell. Order matters: detect-by-file beats
+ * detect-by-installed-tool, since cwd evidence is stronger than "the user
+ * has Cursor installed somewhere on this machine."
+ */
+export function detectDefaultPath(cwd = process.cwd()) {
+  const pkgPath = join(cwd, 'package.json');
+  if (existsSync(pkgPath)) {
+    try {
+      const pkg = JSON.parse(readFileSync(pkgPath, 'utf-8'));
+      const allDeps = {
+        ...(pkg.dependencies ?? {}),
+        ...(pkg.devDependencies ?? {}),
+      };
+      const jsAgentMarkers = ['langchain', '@langchain/core', '@langchain/langgraph', '@mastra/core', 'crewai-js', 'llamaindex'];
+      if (jsAgentMarkers.some((m) => Object.prototype.hasOwnProperty.call(allDeps, m))) {
+        return 'js';
+      }
+      // Generic JS project still defaults to JS (cheaper than asking).
+      return 'js';
+    } catch {
+      // fall through
+    }
+  }
+
+  if (existsSync(join(cwd, 'requirements.txt')) || existsSync(join(cwd, 'pyproject.toml'))) {
+    return 'python';
+  }
+
+  if (isCursorInstalled() || isClaudeCodeInstalled()) {
+    return 'mcp';
+  }
+
+  return null;
+}
+
+function normalizeTarget(target) {
+  if (!target) return null;
+  const t = String(target).toLowerCase();
+  if (!VALID_TARGETS.has(t)) return null;
+  // Aliases — friendly synonyms map to canonical path keys.
+  if (t === 'langchain') return 'js';
+  if (t === 'claude-code') return 'mcp';
+  return t;
+}
+
+async function emitPathChosen(path) {
+  const config = readConfig();
+  if (!config.api_key) return; // wizard didn't get to provision; can't authenticate
+  try {
+    await fetch(`${PLATFORM_URL}/v1/telemetry`, {
+      method: 'POST',
+      headers: {
+        Authorization: `Bearer ${config.api_key}`,
+        'Content-Type': 'application/json',
+      },
+      body: JSON.stringify({
+        product: 'cli',
+        event_type: 'wizard_path_chosen',
+        payload: { path, platform: process.platform },
+      }),
+      signal: AbortSignal.timeout(5_000),
+    });
+  } catch {
+    // Best-effort — never let telemetry break the install path.
+  }
+}
+
+function showJsPath() {
+  blank();
+  success('JS/TS integration');
+  blank();
+  info('Install:');
+  info('  npm install @robot-resources/router');
+  blank();
+  info('Use:');
+  info('  import { routePrompt } from \'@robot-resources/router/routing\';');
+  info('  const decision = routePrompt(\'write a python function\');');
+  info('  console.log(decision.selected_model); // e.g. \'claude-haiku-4-5\'');
+  blank();
+  info('Full docs: https://robotresources.ai/docs/langchain');
+  blank();
+}
+
+function showPythonPath() {
+  blank();
+  success('Python integration');
+  blank();
+  info('Install:');
+  info('  pip install robot-resources-router');
+  blank();
+  info('Use:');
+  info('  from rr_router import route');
+  info('  decision = route(\'write a python function\')');
+  info('  print(decision[\'selected_model\'])  # e.g. \'claude-haiku-4-5\'');
+  blank();
+  info('Full docs: https://robotresources.ai/docs/python');
+  blank();
+}
+
+function showMcpPath() {
+  blank();
+  success('MCP tool integration');
+  blank();
+  let cursorOk = false;
+  let claudeOk = false;
+  if (isCursorInstalled()) {
+    try {
+      const result = configureCursor();
+      cursorOk = result?.action === 'configured' || result?.action === 'already_configured';
+      info(`Cursor: ${cursorOk ? 'configured' : 'see manual instructions below'}`);
+    } catch {
+      warn('Cursor: failed to write ~/.cursor/mcp.json automatically');
+    }
+  }
+  if (isClaudeCodeInstalled()) {
+    try {
+      const result = configureClaudeCode();
+      claudeOk = result?.action === 'configured' || result?.action === 'already_configured';
+      info(`Claude Code: ${claudeOk ? 'configured' : 'see manual instructions below'}`);
+    } catch {
+      warn('Claude Code: failed to write ~/.claude/settings.json automatically');
+    }
+  }
+  if (!cursorOk && !claudeOk) {
+    info('We did not detect Cursor or Claude Code on this machine.');
+    info('Manual setup: https://robotresources.ai/docs/cursor-mcp');
+  }
+  blank();
+}
+
+function showDocsPath() {
+  blank();
+  success('Docs');
+  blank();
+  info('Integration guides: https://robotresources.ai/docs');
+  info('HTTP API:          https://robotresources.ai/docs/http-api');
+  info('GitHub:            https://github.com/robot-resources/robot-resources');
+  blank();
+}
+
+function showInstallOcPath() {
+  blank();
+  info('OpenClaw is the easiest way to use Robot Resources.');
+  info('Install OpenClaw first (https://openclaw.dev), then re-run:');
+  info('  npx robot-resources');
+  blank();
+}
+
+function runPath(path) {
+  switch (path) {
+    case 'js': showJsPath(); break;
+    case 'python': showPythonPath(); break;
+    case 'mcp': showMcpPath(); break;
+    case 'docs': showDocsPath(); break;
+    case 'install-oc': showInstallOcPath(); break;
+    default: showInstallOcPath(); break;
+  }
+}
+
+/**
+ * Runs the non-OC wizard. Three modes:
+ * - target supplied (--for=<target>): run that path directly, no prompt
+ * - non-interactive AND no target: print hint with --for= options and exit
+ * - interactive: 5-option menu via @inquirer/prompts.select
+ */
+export async function runNonOcWizard({ nonInteractive = false, target = null } = {}) {
+  const normalized = normalizeTarget(target);
+
+  if (normalized) {
+    runPath(normalized);
+    await emitPathChosen(normalized);
+    return;
+  }
+
+  if (nonInteractive) {
+    info('Robot Resources requires OpenClaw, which we did not detect on this machine.');
+    info('To bypass this prompt in CI / non-TTY contexts, re-run with --for=<target>:');
+    info('  npx robot-resources --for=langchain      # JS/TS agent');
+    info('  npx robot-resources --for=python         # Python agent');
+    info('  npx robot-resources --for=cursor         # Cursor MCP config');
+    info('  npx robot-resources --for=claude-code    # Claude Code MCP config');
+    info('  npx robot-resources --for=docs           # docs URL');
+    blank();
+    return;
+  }
+
+  // Interactive menu.
+  header();
+  info('Robot Resources requires OpenClaw, which we did not detect on this machine.');
+  info('What are you building? Pick the closest match — we\'ll show the install steps.');
+  blank();
+
+  const defaultPath = detectDefaultPath() ?? 'js';
+
+  let chosen;
+  try {
+    chosen = await select({
+      message: 'What are you building?',
+      default: defaultPath,
+      choices: [
+        { name: PATH_LABELS.js, value: 'js' },
+        { name: PATH_LABELS.python, value: 'python' },
+        { name: PATH_LABELS.mcp, value: 'mcp' },
+        { name: PATH_LABELS.docs, value: 'docs' },
+        { name: PATH_LABELS['install-oc'], value: 'install-oc' },
+      ],
+    });
+  } catch (err) {
+    // User hit Ctrl-C or terminal closed — exit cleanly.
+    if (err && (err.name === 'ExitPromptError' || err.code === 'ABORT_ERR')) return;
+    throw err;
+  }
+
+  runPath(chosen);
+  await emitPathChosen(chosen);
+}

package/lib/wizard.js

@@ -7,6 +7,7 @@ import { getOrCreateMachineId } from './machine-id.js';
 import { configureToolRouting, registerScraperMcp, restartOpenClawGateway } from './tool-config.js';
 import { checkHealth } from './health-report.js';
 import { header, step, success, warn, error, info, blank, summary } from './ui.js';
+import { runNonOcWizard } from './non-oc-wizard.js';
 
 // Stamped onto every CLI telemetry payload so we can tell which `robot-resources`
 // version a user actually ran. Without this, npx-cached old installers look
@@ -41,23 +42,17 @@ const CLI_VERSION = (() => {
  *
  * No Python, no venv, no systemd, no port probe.
  */
-export async function runWizard({ nonInteractive = false } = {}) {
+export async function runWizard({ nonInteractive = false, target = null } = {}) {
   header();
 
-  // Non-OC interactive early-exit. Without this, a human running
-  // `npx robot-resources` on a machine without OpenClaw would still
-  // provision an api_key, fire wizard_started + install_complete
-  // telemetry, and write ~/.robot-resources/config.json — six no-op
-  // side effects against a machine that can't actually use the product.
-  // Non-interactive callers (CI, agents, scripts that pre-set RR_API_KEY)
-  // bypass: they explicitly chose to run the wizard.
-  if (!isOpenClawInstalled() && !nonInteractive) {
-    info('Robot Resources requires OpenClaw, which we did not detect on this machine.');
-    info('Install OpenClaw first (https://openclaw.dev), then re-run:');
-    info('  npx robot-resources');
-    blank();
-    info('If you are integrating Robot Resources into a non-OC agent, see PR 7 docs');
-    info('(coming soon — https://robotresources.ai/docs/integrations).');
+  // Non-OC branch. Hands off to the multi-agent compatibility wizard which
+  // routes the user to the right install path (npm install / pip install /
+  // MCP config / docs / install-OC). Non-interactive callers bypass into the
+  // OC install path only when --for=<target> isn't supplied; otherwise they
+  // get the print-and-exit hint with the supported --for= options.
+  // Pre-PR-8 this was a 17-line print-and-exit; PR 8 made it interactive.
+  if (!isOpenClawInstalled()) {
+    await runNonOcWizard({ nonInteractive, target });
     return;
   }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "robot-resources",
-  "version": "1.10.6",
+  "version": "1.11.0",
   "description": "Robot Resources — AI agent tools. One command to install everything.",
   "type": "module",
   "bin": {
@@ -17,6 +17,7 @@
     "README.md"
   ],
   "dependencies": {
+    "@inquirer/prompts": "^7.0.0",
     "@robot-resources/router": "*",
     "@robot-resources/scraper": "*"
   },