@nexstone/rift-cli 0.1.1 → 0.1.3

package/dist/lib/python-bridge.d.ts

@@ -1,15 +1,35 @@
 /**
  * Bridge between the TypeScript CLI and the Python engine.
- * Spawns Python processes and reads NDJSON output line by line.
+ *
+ * The CLI ships under three install paths:
+ *
+ *   1. Source clone — `engine/` directory exists above the CLI binary.
+ *      We invoke `python -m rift.cli` with PYTHONPATH set to `engine/src`.
+ *      Used during development.
+ *
+ *   2. Installed wheel — user did `pip install rift-engine-core`. The
+ *      wheel ships a `rift-engine` console script as its entry point.
+ *      We invoke that binary directly. Used for end-user pip/brew installs.
+ *
+ *   3. Env override — `RIFT_ENGINE_BINARY=/path/to/rift-engine` forces us
+ *      to use a specific binary. Used by the Homebrew formula to point at
+ *      the libexec venv's rift-engine even if PATH is weird.
+ *
+ * Detection runs in priority order: env override → source → installed.
+ * Each spawned process inherits the same environment + extraEnv overlay.
  */
+import { type ChildProcess } from 'node:child_process';
 export interface EngineMessage {
     type: 'progress' | 'result' | 'error' | 'status' | 'trade' | 'candle' | 'heartbeat' | 'shutdown' | 'step' | 'step_done' | 'soak';
     [key: string]: unknown;
 }
 export declare function getDataDir(): string;
+/** Public helper — install-mode-aware strategies dir, for commands that
+ *  scaffold or list strategies. */
+export declare function resolveStrategiesDir(): string;
 export declare function runEngine(command: string, args: string[], onMessage: (msg: EngineMessage) => void, extraEnv?: Record<string, string>): Promise<void>;
 /** Get the child process from a runEngine promise (for sending signals) */
-export declare function getEngineProcess(promise: Promise<void>): import('node:child_process').ChildProcess | null;
+export declare function getEngineProcess(promise: Promise<void>): ChildProcess | null;
 /**
  * Spawn the Python engine as a detached daemon process.
  * Returns immediately after the process is started.

package/dist/lib/python-bridge.js

@@ -1,84 +1,179 @@
 /**
  * Bridge between the TypeScript CLI and the Python engine.
- * Spawns Python processes and reads NDJSON output line by line.
+ *
+ * The CLI ships under three install paths:
+ *
+ *   1. Source clone — `engine/` directory exists above the CLI binary.
+ *      We invoke `python -m rift.cli` with PYTHONPATH set to `engine/src`.
+ *      Used during development.
+ *
+ *   2. Installed wheel — user did `pip install rift-engine-core`. The
+ *      wheel ships a `rift-engine` console script as its entry point.
+ *      We invoke that binary directly. Used for end-user pip/brew installs.
+ *
+ *   3. Env override — `RIFT_ENGINE_BINARY=/path/to/rift-engine` forces us
+ *      to use a specific binary. Used by the Homebrew formula to point at
+ *      the libexec venv's rift-engine even if PATH is weird.
+ *
+ * Detection runs in priority order: env override → source → installed.
+ * Each spawned process inherits the same environment + extraEnv overlay.
  */
 import { spawn, execSync } from 'node:child_process';
 import { createInterface } from 'node:readline';
 import * as path from 'node:path';
 import * as fs from 'node:fs';
+import * as os from 'node:os';
 import { fileURLToPath } from 'node:url';
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
-function getEngineDir() {
+/** Walk up looking for `engine/pyproject.toml` + `engine/src/rift/cli.py`.
+ *  Only present in a source clone, not in any installed layout. */
+function findSourceEngineDir() {
     let dir = path.resolve(__dirname);
     for (let i = 0; i < 10; i++) {
         const engineDir = path.join(dir, 'engine');
-        // Require both pyproject.toml AND the rift.cli entry point.
-        // Prevents matching packages/engine (the new rift_engine library)
-        // before reaching the legacy engine/ host that owns -m rift.cli.
+        // Both probes required to avoid matching `packages/engine/` (the
+        // rift_engine library subpackage) before reaching the real `engine/`
+        // host that owns `rift.cli`.
         if (fs.existsSync(path.join(engineDir, 'pyproject.toml')) &&
             fs.existsSync(path.join(engineDir, 'src', 'rift', 'cli.py')))
             return engineDir;
-        dir = path.dirname(dir);
+        const parent = path.dirname(dir);
+        if (parent === dir)
+            break;
+        dir = parent;
     }
-    throw new Error('Cannot find RIFT engine directory');
+    return null;
 }
-function findPython() {
-    // Check engine's uv-managed venv first
-    const engineVenv = path.join(getEngineDir(), '.venv', 'bin', 'python3');
+/** Locate a binary on PATH via `which`. Returns null if not found. */
+function findOnPath(binary) {
+    try {
+        const out = execSync(`command -v ${binary}`, { encoding: 'utf-8', stdio: ['ignore', 'pipe', 'ignore'] }).trim();
+        return out || null;
+    }
+    catch {
+        return null;
+    }
+}
+function detectEngine() {
+    // 1. Env override
+    const envBinary = process.env.RIFT_ENGINE_BINARY;
+    if (envBinary && fs.existsSync(envBinary)) {
+        return { kind: 'installed', binary: envBinary };
+    }
+    // 2. Source clone
+    const sourceDir = findSourceEngineDir();
+    if (sourceDir) {
+        return { kind: 'source', engineDir: sourceDir };
+    }
+    // 3. Installed wheel — rift-engine on PATH
+    const binary = findOnPath('rift-engine');
+    if (binary) {
+        return { kind: 'installed', binary };
+    }
+    throw new Error('Cannot find RIFT engine.\n' +
+        '\n' +
+        'Install one of:\n' +
+        '  brew install Nexstone/tap/rift          # all-in-one, recommended\n' +
+        '  pip install rift-engine-core            # Python engine only\n' +
+        '\n' +
+        'Or set RIFT_ENGINE_BINARY=/path/to/rift-engine to use a specific install.');
+}
+/** Find Python for source mode. Prefers the engine's uv-managed venv. */
+function findPythonForSource(engineDir) {
+    const engineVenv = path.join(engineDir, '.venv', 'bin', 'python3');
     if (fs.existsSync(engineVenv))
         return engineVenv;
-    // Check for managed venv in data dir
     const dataVenv = path.join(getDataDir(), 'venv', 'bin', 'python3');
     if (fs.existsSync(dataVenv))
         return dataVenv;
-    // Fall back to system Python
     for (const cmd of ['python3.14', 'python3.13', 'python3']) {
         try {
             execSync(`${cmd} --version`, { stdio: 'ignore' });
             return cmd;
         }
         catch {
-            continue;
+            // try next
         }
     }
     throw new Error('Python 3.13+ not found. Install Python or run: rift setup');
 }
-function getStrategiesDir() {
-    let dir = path.resolve(__dirname);
-    for (let i = 0; i < 10; i++) {
-        const strategiesDir = path.join(dir, 'strategies');
-        if (fs.existsSync(strategiesDir))
-            return strategiesDir;
-        dir = path.dirname(dir);
+function getStrategiesDir(engine) {
+    if (engine.kind === 'source') {
+        // Walk up from the CLI's location looking for a `strategies/` sibling
+        // to engine/. Falls back to <repo-root>/strategies.
+        let dir = path.resolve(__dirname);
+        for (let i = 0; i < 10; i++) {
+            const stratDir = path.join(dir, 'strategies');
+            if (fs.existsSync(stratDir))
+                return stratDir;
+            const parent = path.dirname(dir);
+            if (parent === dir)
+                break;
+            dir = parent;
+        }
+        return path.join(engine.engineDir, '..', 'strategies');
+    }
+    // Installed mode: strategies live under the user's data dir. We create
+    // it on demand so `rift new` and `rift algo` see the same path even
+    // if the user never explicitly initialized it.
+    const stratDir = path.join(getDataDir(), 'strategies');
+    if (!fs.existsSync(stratDir)) {
+        fs.mkdirSync(stratDir, { recursive: true });
     }
-    const projectRoot = path.resolve(__dirname, '..', '..', '..', '..');
-    return path.join(projectRoot, 'strategies');
+    return stratDir;
 }
 export function getDataDir() {
-    return path.join(process.env.HOME || '~', '.rift');
+    return path.join(process.env.HOME || os.homedir(), '.rift');
 }
-export async function runEngine(command, args, onMessage, extraEnv) {
-    const python = findPython();
-    const engineDir = getEngineDir();
-    const strategiesDir = getStrategiesDir();
-    const fullArgs = [
-        '-m', 'rift.cli',
-        command,
-        ...args,
-    ];
-    // Only add --strategies-dir for commands that accept it
-    if (['backtest', 'strategies', 'compare', 'walk-forward', 'sweep', 'montecarlo', 'portfolio-backtest', 'research', 'quick-test', 'algo'].includes(command)) {
-        fullArgs.push('--strategies-dir', strategiesDir);
+/** Public helper — install-mode-aware strategies dir, for commands that
+ *  scaffold or list strategies. */
+export function resolveStrategiesDir() {
+    return getStrategiesDir(detectEngine());
+}
+const COMMANDS_WITH_STRATEGIES_DIR = new Set([
+    'backtest', 'strategies', 'compare', 'walk-forward',
+    'sweep', 'montecarlo', 'portfolio-backtest', 'research',
+    'quick-test', 'algo',
+]);
+function buildSpawnPlan(command, args, extraEnv, engine) {
+    const finalArgs = [];
+    let cmd;
+    let cwd;
+    let env;
+    if (engine.kind === 'source') {
+        const python = findPythonForSource(engine.engineDir);
+        cmd = python;
+        finalArgs.push('-m', 'rift.cli');
+        cwd = engine.engineDir;
+        env = {
+            ...process.env,
+            ...extraEnv,
+            PYTHONPATH: path.join(engine.engineDir, 'src'),
+            PYTHONUNBUFFERED: '1',
+        };
     }
-    const proc = spawn(python, fullArgs, {
-        cwd: engineDir,
-        env: {
+    else {
+        cmd = engine.binary;
+        cwd = undefined; // inherit caller's cwd
+        env = {
             ...process.env,
             ...extraEnv,
-            PYTHONPATH: path.join(engineDir, 'src'),
             PYTHONUNBUFFERED: '1',
-        },
+        };
+    }
+    finalArgs.push(command, ...args);
+    if (COMMANDS_WITH_STRATEGIES_DIR.has(command)) {
+        finalArgs.push('--strategies-dir', getStrategiesDir(engine));
+    }
+    return { cmd, args: finalArgs, env, cwd };
+}
+export async function runEngine(command, args, onMessage, extraEnv) {
+    const engine = detectEngine();
+    const plan = buildSpawnPlan(command, args, extraEnv, engine);
+    const proc = spawn(plan.cmd, plan.args, {
+        cwd: plan.cwd,
+        env: plan.env,
         stdio: ['ignore', 'pipe', 'pipe'],
     });
     const promise = new Promise((resolve, reject) => {
@@ -135,7 +230,7 @@ export async function runEngine(command, args, onMessage, extraEnv) {
 }
 /** Get the child process from a runEngine promise (for sending signals) */
 export function getEngineProcess(promise) {
-    return promise?._proc ?? null;
+    return promise._proc ?? null;
 }
 /**
  * Spawn the Python engine as a detached daemon process.
@@ -143,24 +238,13 @@ export function getEngineProcess(promise) {
  * The daemon writes its own PID file and log file.
  */
 export function spawnDaemon(command, args, extraEnv) {
-    const python = findPython();
-    const engineDir = getEngineDir();
-    const fullArgs = [
-        '-m', 'rift.cli',
-        command,
-        ...args,
-        '--daemon',
-    ];
+    const engine = detectEngine();
+    const plan = buildSpawnPlan(command, [...args, '--daemon'], extraEnv, engine);
     // Open /dev/null for stdio — daemon writes to its own log file
     const devNull = fs.openSync('/dev/null', 'r+');
-    const proc = spawn(python, fullArgs, {
-        cwd: engineDir,
-        env: {
-            ...process.env,
-            ...extraEnv,
-            PYTHONPATH: path.join(engineDir, 'src'),
-            PYTHONUNBUFFERED: '1',
-        },
+    const proc = spawn(plan.cmd, plan.args, {
+        cwd: plan.cwd,
+        env: plan.env,
         stdio: [devNull, devNull, devNull],
         detached: true,
     });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nexstone/rift-cli",
-  "version": "0.1.1",
+  "version": "0.1.3",
   "description": "RIFT — Research / Iteration / Forecast / Trade",
   "license": "Apache-2.0",
   "type": "module",