@rind-ai/cli 0.4.1

package/lib/runtime-client.js

@@ -0,0 +1,201 @@
+import { spawn, spawnSync } from "node:child_process";
+import path from "node:path";
+
+import { buildRuntimeEnv } from "./runtime-env.js";
+import { createRuntimeRequest, runtimeRequestId } from "./runtime-protocol.js";
+
+export function resolveRuntimeLaunch({ python, repoRoot, runtimePath = "", cliArgs = [] }) {
+  const executable = runtimePath
+    ? { command: runtimePath, args: [] }
+    : { command: python, args: [path.join(repoRoot, "main.py")] };
+  const traceFlag = isTraceLlmEnvSet() ? ["--trace-llm"] : [];
+  return {
+    command: executable.command,
+    args: [...executable.args, "app-server", "--stdio", ...traceFlag, ...cliArgs],
+  };
+}
+
+const TRACE_TRUTHY = new Set(["1", "true", "yes", "on"]);
+export function isTraceLlmEnvSet() {
+  return TRACE_TRUTHY.has(String(process.env.RIND_TRACE_LLM || "").trim().toLowerCase());
+}
+
+export function runHelpVersion({ python, repoRoot, runtimePath = "", cliArgs, cwd = process.cwd() }) {
+  const executable = runtimePath
+    ? { command: runtimePath, args: [] }
+    : { command: python, args: [path.join(repoRoot, "main.py")] };
+  const result = spawnSync(executable.command, [...executable.args, ...cliArgs], {
+    cwd,
+    env: buildRuntimeEnv(repoRoot, process.env, { sourceRuntime: !runtimePath }),
+    stdio: "inherit",
+  });
+  return result.status ?? 1;
+}
+
+export function createRuntimeClient({
+  python,
+  repoRoot,
+  cliArgs = [],
+  cwd = process.cwd(),
+  rindHome = process.env.RIND_HOME,
+  runtimePath = process.env.RIND_RUNTIME_PATH || "",
+  onEvent = () => {},
+  onMessage = null,
+  onStderr = () => {},
+  onExit = () => {},
+}) {
+  const handleEvent = onMessage || onEvent;
+  const launch = resolveRuntimeLaunch({ python, repoRoot, runtimePath, cliArgs });
+
+  let nextId = 1;
+  let stdoutBuffer = "";
+  let closing = false;
+  let killTimer = null;
+  let exitHandled = false;
+  const pending = new Map();
+  const child = spawn(launch.command, launch.args, {
+    cwd,
+    env: buildRuntimeEnv(repoRoot, process.env, {
+      sourceRuntime: !runtimePath,
+      rindHome,
+    }),
+    stdio: ["pipe", "pipe", "pipe"],
+  });
+
+  child.stdout.setEncoding("utf8");
+  child.stdout.on("data", (chunk) => {
+    stdoutBuffer += chunk;
+    const lines = stdoutBuffer.split(/\r?\n/);
+    stdoutBuffer = lines.pop() || "";
+    for (const line of lines) {
+      if (line) {
+        receive(line);
+      }
+    }
+  });
+  child.stderr.on("data", (chunk) => onStderr(chunk));
+  child.once("error", (error) => {
+    handleExit(null, null, error);
+  });
+  child.once("exit", (code, signal) => {
+    handleExit(code, signal);
+  });
+
+  function handleExit(code, signal, cause = null) {
+    if (exitHandled) {
+      return;
+    }
+    exitHandled = true;
+    clearKillTimer();
+    const error = cause || new Error(`Runtime exited with ${signal || code}`);
+    for (const { reject } of pending.values()) {
+      reject(error);
+    }
+    pending.clear();
+    onExit(code, signal, { closing, error });
+  }
+
+  function request(method, params = {}) {
+    const id = nextId++;
+    return new Promise((resolve, reject) => {
+      if (!child.stdin.writable || child.destroyed) {
+        reject(new Error("Runtime stdin is closed. Restart Rind and try again."));
+        return;
+      }
+      pending.set(id, { resolve, reject });
+      child.stdin.write(JSON.stringify(createRuntimeRequest(id, method, params)) + "\n", (error) => {
+        if (!error) {
+          return;
+        }
+        pending.delete(id);
+        reject(error);
+      });
+    });
+  }
+
+  function receive(line) {
+    let message;
+    try {
+      message = JSON.parse(line);
+    } catch {
+      return;
+    }
+    if (message.kind === "response") {
+      finishRequest(message);
+      return;
+    }
+    if (message.kind === "event") {
+      handleEvent(message);
+    }
+  }
+
+  function finishRequest(message) {
+    const id = runtimeRequestId(message);
+    const callbacks = pending.get(id);
+    if (!callbacks) {
+      return;
+    }
+    pending.delete(id);
+    if (message.error) {
+      callbacks.reject(new Error(message.error.message || "Runtime request failed"));
+    } else {
+      callbacks.resolve(message.result);
+    }
+  }
+
+  function shutdown() {
+    if (closing) {
+      return Promise.resolve();
+    }
+    closing = true;
+    scheduleKill();
+    return request("shutdown").catch(() => {
+      forceShutdown();
+    }).finally(() => {
+      if (child.stdin.writable) {
+        child.stdin.end();
+      }
+    });
+  }
+
+  function forceShutdown() {
+    closing = true;
+    clearKillTimer();
+    if (!child.killed && child.exitCode === null) {
+      try {
+        child.kill("SIGKILL");
+      } catch {
+        // Ignore kill races during shutdown.
+      }
+    }
+  }
+
+  function closeInput() {
+    if (child.stdin.writable) {
+      child.stdin.end();
+    }
+  }
+
+  function scheduleKill() {
+    clearKillTimer();
+    killTimer = setTimeout(forceShutdown, 1500);
+    killTimer.unref?.();
+  }
+
+  function clearKillTimer() {
+    if (!killTimer) {
+      return;
+    }
+    clearTimeout(killTimer);
+    killTimer = null;
+  }
+
+  return {
+    child,
+    request,
+    shutdown,
+    forceShutdown,
+    closeInput,
+    isClosing: () => closing,
+  };
+}

package/lib/runtime-env.js

@@ -0,0 +1,21 @@
+import path from "node:path";
+
+export function buildRuntimeEnv(repoRoot, baseEnv = process.env, { sourceRuntime = true, rindHome } = {}) {
+  const env = { ...baseEnv };
+  if (rindHome) {
+    env.RIND_HOME = rindHome;
+  }
+  if (!sourceRuntime) {
+    return env;
+  }
+  return {
+    ...env,
+    PYTHONIOENCODING: "utf-8",
+    PYTHONPATH: prependPath(repoRoot, baseEnv.PYTHONPATH),
+    PYTHONUTF8: "1",
+  };
+}
+
+function prependPath(entry, value) {
+  return value ? `${entry}${path.delimiter}${value}` : entry;
+}

package/lib/runtime-protocol.js

@@ -0,0 +1,15 @@
+export function createRuntimeRequest(requestId, method, params = {}) {
+  return { request_id: requestId, method, params };
+}
+
+export function runtimeRequestId(message) {
+  return message?.request_id;
+}
+
+export function runtimeEventType(message) {
+  return message?.event_type || message?.event?.type || "";
+}
+
+export function turnInputMethod(activeTurn) {
+  return activeTurn ? "turn.follow_up" : "turn.start";
+}

package/lib/slash-command-mode.js

@@ -0,0 +1,27 @@
+export function isReadonlySlashCommand(value) {
+  const text = String(value || "").trim().toLowerCase();
+  return text === "/status" || text.startsWith("/status ") || text === "/doctor" || text.startsWith("/doctor ");
+}
+
+export function steeringCommandText(value) {
+  const text = String(value || "").trim();
+  const match = text.match(/^\/steer(?:\s+([\s\S]*))?$/i);
+  return match ? String(match[1] || "").trim() : null;
+}
+
+export function parseGoalCommand(value) {
+  const text = String(value || "").trim();
+  const match = text.match(/^\/goal(?:\s+([\s\S]*))?$/i);
+  if (!match) {
+    return null;
+  }
+  const argument = String(match[1] || "").trim();
+  const action = argument.toLowerCase();
+  if (!argument) {
+    return { action: "get" };
+  }
+  if (["pause", "resume", "clear"].includes(action)) {
+    return { action };
+  }
+  return { action: "set", objective: argument };
+}

package/lib/slash-menu-state.js

@@ -0,0 +1,59 @@
+export function createSlashMenuState(commands) {
+  let text = "";
+  let selected = 0;
+  let dismissed = false;
+  return {
+    input() {
+      return text;
+    },
+    matches() {
+      return dismissed ? [] : matchingCommands(commands, text);
+    },
+    selectedIndex() {
+      return selected;
+    },
+    selectedCommand() {
+      return this.matches()[selected] || null;
+    },
+    handleKey(chunk, key = {}) {
+      if (key.name === "escape") {
+        dismissed = true;
+        selected = 0;
+        return true;
+      }
+      const matches = this.matches();
+      if (matches.length && key.name === "up") {
+        selected = selected <= 0 ? matches.length - 1 : selected - 1;
+        return true;
+      }
+      if (matches.length && key.name === "down") {
+        selected = selected >= matches.length - 1 ? 0 : selected + 1;
+        return true;
+      }
+      if (chunk && !key.ctrl && !key.meta && String(chunk) >= " ") {
+        text += String(chunk);
+        selected = 0;
+        dismissed = false;
+        return true;
+      }
+      return false;
+    },
+    setInput(value) {
+      const nextText = String(value || "");
+      if (nextText !== text) {
+        selected = 0;
+        dismissed = false;
+      }
+      text = nextText;
+    },
+  };
+}
+
+function matchingCommands(commands, line) {
+  const text = String(line || "");
+  if (!text.startsWith("/") || /\s/.test(text)) {
+    return [];
+  }
+  const token = text.slice(1).toLowerCase();
+  return commands.filter((command) => command.name.startsWith(token));
+}

package/lib/terminal-key.js

@@ -0,0 +1,97 @@
+const ARROW_KEYS = {
+  A: "up",
+  B: "down",
+  C: "right",
+  D: "left",
+  H: "home",
+  F: "end",
+};
+
+export function parseTerminalKey(raw = "") {
+  const value = String(raw || "");
+  if (!value) {
+    return null;
+  }
+  if (value === "\r" || value === "\x1bOM") {
+    return key("enter");
+  }
+  if (value === "\n") {
+    return key("j", 5);
+  }
+  if (value === "\t") {
+    return key("tab");
+  }
+  if (value === "\b") {
+    return key("backspace", process.platform === "win32" && process.env.WT_SESSION ? 5 : 1);
+  }
+  if (value === "\x7f") {
+    return key("backspace");
+  }
+  if (value === "\x1f") {
+    return key("-", 5);
+  }
+  if (value === "\x1b") {
+    return key("escape");
+  }
+  if (value.length === 1) {
+    const code = value.charCodeAt(0);
+    if (code >= 1 && code <= 26) {
+      return key(String.fromCharCode(96 + code), 5);
+    }
+    if (code < 32) {
+      return null;
+    }
+    return { kind: "text", name: "", text: value };
+  }
+
+  const modifiedArrow = value.match(/^\x1b\[1;([2-8])([ABCDHF])$/);
+  if (modifiedArrow) {
+    return key(ARROW_KEYS[modifiedArrow[2]], Number(modifiedArrow[1]));
+  }
+  const tilde = value.match(/^\x1b\[([0-9]+)(?:;([2-8]))?~$/);
+  if (tilde) {
+    return Number(tilde[1]) === 3 ? key("delete", Number(tilde[2] || 1)) : null;
+  }
+  const csiKey = value.match(/^\x1b\[([ABCDHFZ])$/);
+  if (csiKey) {
+    return csiKey[1] === "Z" ? key("tab", 2) : key(ARROW_KEYS[csiKey[1]]);
+  }
+  const ss3Key = value.match(/^\x1bO([ABCDHF])$/);
+  if (ss3Key) {
+    return key(ARROW_KEYS[ss3Key[1]]);
+  }
+  const csiEnter = value.match(/^\x1b\[13;([2-8])u$/);
+  if (csiEnter) {
+    return key("enter", Number(csiEnter[1]));
+  }
+  const csiMinus = value.match(/^\x1b\[45;([2-8])u$/);
+  if (csiMinus) {
+    return key("-", Number(csiMinus[1]));
+  }
+  const modifiedEnter = value.match(/^\x1b\[27;([2-8]);13~$/);
+  if (modifiedEnter) {
+    return key("enter", Number(modifiedEnter[1]));
+  }
+  if (value === "\x1b\r") {
+    return key("enter", 2);
+  }
+  if (value.startsWith("\x1b") && value.length === 2) {
+    return key(value[1] === "\x7f" || value[1] === "\b" ? "backspace" : value[1], 3);
+  }
+  if (value.startsWith("\x1b")) {
+    return null;
+  }
+  return { kind: "text", name: "", text: value };
+}
+
+function key(name, modifier = 1) {
+  const bits = modifier - 1;
+  return {
+    kind: "key",
+    name,
+    shift: Boolean(bits & 1),
+    alt: Boolean(bits & 2),
+    ctrl: Boolean(bits & 4),
+    text: "",
+  };
+}