rex-claude 4.0.0 → 6.0.0

package/dist/app-3VWDSH5F.js

@@ -0,0 +1,248 @@
+#!/usr/bin/env node
+import "./chunk-PDX44BCA.js";
+
+// src/app.ts
+import { existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "fs";
+import { execSync } from "child_process";
+import { dirname, join, resolve } from "path";
+var COLORS = {
+  reset: "\x1B[0m",
+  green: "\x1B[32m",
+  yellow: "\x1B[33m",
+  red: "\x1B[31m",
+  bold: "\x1B[1m",
+  cyan: "\x1B[36m",
+  dim: "\x1B[2m"
+};
+var CANONICAL_APP = "/Applications/rex_app.app";
+var LEGACY_APP = "/Applications/REX.app";
+function ok(msg) {
+  console.log(`  ${COLORS.green}\u2713${COLORS.reset} ${msg}`);
+}
+function info(msg) {
+  console.log(`  ${COLORS.cyan}\u2139${COLORS.reset} ${msg}`);
+}
+function fail(msg) {
+  console.log(`  ${COLORS.red}\u2717${COLORS.reset} ${msg}`);
+}
+function commandExists(cmd) {
+  try {
+    execSync(`command -v ${cmd}`, { stdio: "ignore" });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function findRepoRoot(startDir = process.cwd()) {
+  let current = resolve(startDir);
+  while (true) {
+    const flutterPubspec = join(current, "packages", "flutter_app", "pubspec.yaml");
+    if (existsSync(flutterPubspec)) return current;
+    const parent = dirname(current);
+    if (parent === current) break;
+    current = parent;
+  }
+  return null;
+}
+function getBuildBundle(repoRoot, mode) {
+  return join(
+    repoRoot,
+    "packages",
+    "flutter_app",
+    "build",
+    "macos",
+    "Build",
+    "Products",
+    mode === "release" ? "Release" : "Debug",
+    "rex_app.app"
+  );
+}
+function buildFlutterApp(repoRoot, mode) {
+  if (!commandExists("flutter")) {
+    throw new Error("flutter command not found in PATH");
+  }
+  const flutterDir = join(repoRoot, "packages", "flutter_app");
+  const flag = mode === "release" ? "--release" : "--debug";
+  info(`Building Flutter macOS app (${mode})...`);
+  execSync(`flutter build macos ${flag}`, { cwd: flutterDir, stdio: "inherit" });
+}
+function gitInfo(repoRoot) {
+  let branch = "unknown";
+  let commit = "unknown";
+  let dirty = false;
+  try {
+    branch = execSync("git rev-parse --abbrev-ref HEAD", { cwd: repoRoot, encoding: "utf-8" }).trim();
+  } catch {
+  }
+  try {
+    commit = execSync("git rev-parse --short HEAD", { cwd: repoRoot, encoding: "utf-8" }).trim();
+  } catch {
+  }
+  try {
+    dirty = execSync("git status --porcelain", { cwd: repoRoot, encoding: "utf-8" }).trim().length > 0;
+  } catch {
+  }
+  return { branch, commit, dirty };
+}
+function installAppBundle(sourceBundle) {
+  if (!existsSync(sourceBundle)) throw new Error(`Build bundle not found: ${sourceBundle}`);
+  info(`Installing app to ${CANONICAL_APP}`);
+  rmSync(CANONICAL_APP, { recursive: true, force: true });
+  rmSync(LEGACY_APP, { recursive: true, force: true });
+  execSync(`ditto "${sourceBundle}" "${CANONICAL_APP}"`, { stdio: "ignore" });
+  try {
+    execSync(`ln -sfn "${CANONICAL_APP}" "${LEGACY_APP}"`, { stdio: "ignore" });
+  } catch {
+  }
+}
+function writeBuildInfo(infoData) {
+  const resourcesDir = join(CANONICAL_APP, "Contents", "Resources");
+  mkdirSync(resourcesDir, { recursive: true });
+  const infoPath = join(resourcesDir, "rex-build-info.json");
+  writeFileSync(infoPath, JSON.stringify(infoData, null, 2) + "\n");
+}
+function readBuildInfo() {
+  const infoPath = join(CANONICAL_APP, "Contents", "Resources", "rex-build-info.json");
+  if (!existsSync(infoPath)) return null;
+  try {
+    return JSON.parse(readFileSync(infoPath, "utf-8"));
+  } catch {
+    return null;
+  }
+}
+function relaunchApp() {
+  try {
+    execSync(`pkill -f '/Contents/MacOS/rex_app'`, { stdio: "ignore" });
+  } catch {
+  }
+  execSync(`open -a "${CANONICAL_APP}"`, { stdio: "ignore" });
+}
+function printAppInfo() {
+  console.log(`
+${COLORS.bold}REX App Info${COLORS.reset}`);
+  console.log(`  Canonical path: ${CANONICAL_APP} ${existsSync(CANONICAL_APP) ? `${COLORS.green}(installed)${COLORS.reset}` : `${COLORS.red}(missing)${COLORS.reset}`}`);
+  console.log(`  Legacy path:    ${LEGACY_APP} ${existsSync(LEGACY_APP) ? `${COLORS.yellow}(alias present)${COLORS.reset}` : `${COLORS.dim}(none)${COLORS.reset}`}`);
+  const infoData = readBuildInfo();
+  if (infoData) {
+    console.log(`  Source repo:    ${infoData.sourceRepo}`);
+    console.log(`  Git:            ${infoData.git.branch}@${infoData.git.commit}${infoData.git.dirty ? " (dirty)" : ""}`);
+    console.log(`  Build mode:     ${infoData.buildMode}`);
+    console.log(`  Installed at:   ${infoData.installedAt}`);
+  } else {
+    console.log(`  ${COLORS.dim}No build metadata found (install once via \`rex app update\`).${COLORS.reset}`);
+  }
+  try {
+    const running = execSync(`pgrep -fal '/Contents/MacOS/rex_app'`, { encoding: "utf-8" }).trim();
+    if (running) {
+      console.log(`  Running process:
+${running.split("\n").map((line) => `    ${line}`).join("\n")}`);
+    } else {
+      console.log(`  Running process: ${COLORS.dim}none${COLORS.reset}`);
+    }
+  } catch {
+    console.log(`  Running process: ${COLORS.dim}none${COLORS.reset}`);
+  }
+  console.log("");
+}
+function usage() {
+  console.log(`
+${COLORS.bold}REX App Commands${COLORS.reset}
+  rex app update [--debug|--release] [--no-launch] [--no-build]
+  rex app info
+  rex app open
+`);
+}
+function parseMode(args) {
+  if (args.includes("--release")) return "release";
+  return "debug";
+}
+function hasFlag(args, flag) {
+  return args.includes(flag);
+}
+function ensureDarwin() {
+  if (process.platform !== "darwin") {
+    throw new Error("App install/update is only supported on macOS");
+  }
+}
+function updateApp(args) {
+  ensureDarwin();
+  const mode = parseMode(args);
+  const launch = !hasFlag(args, "--no-launch");
+  const noBuild = hasFlag(args, "--no-build");
+  const repoRoot = findRepoRoot();
+  if (!repoRoot) {
+    throw new Error("REX monorepo not found from current directory (need packages/flutter_app)");
+  }
+  if (!noBuild) buildFlutterApp(repoRoot, mode);
+  let sourceBundle = getBuildBundle(repoRoot, mode);
+  if (!existsSync(sourceBundle)) {
+    const fallbackMode = mode === "debug" ? "release" : "debug";
+    const fallbackBundle = getBuildBundle(repoRoot, fallbackMode);
+    if (existsSync(fallbackBundle)) {
+      info(`Requested ${mode} bundle not found, using existing ${fallbackMode} bundle`);
+      sourceBundle = fallbackBundle;
+    } else {
+      throw new Error(`No built app found. Expected:
+- ${sourceBundle}
+- ${fallbackBundle}`);
+    }
+  }
+  installAppBundle(sourceBundle);
+  const git = gitInfo(repoRoot);
+  writeBuildInfo({
+    installedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    sourceRepo: repoRoot,
+    buildMode: mode,
+    sourceBundle,
+    git
+  });
+  ok(`Installed ${CANONICAL_APP}`);
+  info(`Source: ${repoRoot} (${git.branch}@${git.commit}${git.dirty ? ", dirty" : ""})`);
+  info(`Mode: ${mode}`);
+  if (launch) {
+    relaunchApp();
+    ok("REX app launched");
+  } else {
+    info("Launch skipped (--no-launch)");
+  }
+}
+function openApp() {
+  ensureDarwin();
+  if (existsSync(CANONICAL_APP)) {
+    execSync(`open -a "${CANONICAL_APP}"`, { stdio: "ignore" });
+    ok("REX app opened");
+    return;
+  }
+  if (existsSync(LEGACY_APP)) {
+    execSync(`open -a "${LEGACY_APP}"`, { stdio: "ignore" });
+    ok("REX app opened");
+    return;
+  }
+  throw new Error("No installed app found. Run `rex app update` first.");
+}
+async function app(args) {
+  const sub = args[0] ?? "help";
+  try {
+    switch (sub) {
+      case "update":
+        updateApp(args.slice(1));
+        break;
+      case "info":
+        printAppInfo();
+        break;
+      case "open":
+        openApp();
+        break;
+      case "help":
+      default:
+        usage();
+        break;
+    }
+  } catch (error) {
+    fail(error?.message ?? String(error));
+    process.exit(1);
+  }
+}
+export {
+  app
+};

package/dist/audio-US2J627E.js

@@ -0,0 +1,196 @@
+#!/usr/bin/env node
+import "./chunk-PDX44BCA.js";
+
+// src/audio.ts
+import { homedir } from "os";
+import { existsSync, mkdirSync, readdirSync, readFileSync, writeFileSync } from "fs";
+import { join } from "path";
+import { spawn, spawnSync } from "child_process";
+var HOME = homedir();
+var RUNTIME_DIR = join(HOME, ".rex-memory", "runtime");
+var RECORDINGS_DIR = join(HOME, ".rex-memory", "recordings");
+var STATE_FILE = join(RUNTIME_DIR, "audio-logger.json");
+function ensureDirs() {
+  if (!existsSync(RUNTIME_DIR)) mkdirSync(RUNTIME_DIR, { recursive: true });
+  if (!existsSync(RECORDINGS_DIR)) mkdirSync(RECORDINGS_DIR, { recursive: true });
+}
+function ffmpegExists() {
+  const check = spawnSync("ffmpeg", ["-version"], { stdio: "ignore" });
+  return check.status === 0;
+}
+function readState() {
+  try {
+    if (existsSync(STATE_FILE)) {
+      const parsed = JSON.parse(readFileSync(STATE_FILE, "utf-8"));
+      return {
+        pid: typeof parsed.pid === "number" ? parsed.pid : null,
+        startedAt: typeof parsed.startedAt === "string" ? parsed.startedAt : null,
+        currentFile: typeof parsed.currentFile === "string" ? parsed.currentFile : null
+      };
+    }
+  } catch {
+  }
+  return { pid: null, startedAt: null, currentFile: null };
+}
+function writeState(state) {
+  ensureDirs();
+  writeFileSync(STATE_FILE, JSON.stringify(state, null, 2));
+}
+function isPidRunning(pid) {
+  if (!pid || pid <= 0) return false;
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function listRecordings() {
+  ensureDirs();
+  return readdirSync(RECORDINGS_DIR).filter((f) => f.endsWith(".wav")).sort().reverse();
+}
+function currentStatus() {
+  const state = readState();
+  const capturing = isPidRunning(state.pid);
+  const recordings = listRecordings();
+  return {
+    capturing,
+    pid: capturing ? state.pid : null,
+    recordingsDir: RECORDINGS_DIR,
+    recordingsCount: recordings.length,
+    currentFile: capturing ? state.currentFile : null,
+    startedAt: capturing ? state.startedAt : null
+  };
+}
+function printStatus(status, jsonMode) {
+  if (jsonMode) {
+    console.log(JSON.stringify(status, null, 2));
+    return;
+  }
+  console.log(`Audio logger: ${status.capturing ? "recording" : "idle"}`);
+  console.log(`Recordings: ${status.recordingsCount}`);
+  console.log(`Directory: ${status.recordingsDir}`);
+  if (status.currentFile) console.log(`Current: ${status.currentFile}`);
+}
+function startCapture(jsonMode) {
+  ensureDirs();
+  if (!ffmpegExists()) {
+    const msg = "ffmpeg not found. Install ffmpeg to use audio logger (brew install ffmpeg).";
+    if (jsonMode) {
+      console.log(JSON.stringify({ ok: false, error: msg }));
+      return;
+    }
+    console.error(msg);
+    process.exit(1);
+  }
+  const state = readState();
+  if (isPidRunning(state.pid)) {
+    const status2 = currentStatus();
+    if (jsonMode) {
+      console.log(JSON.stringify({ ok: true, alreadyRunning: true, ...status2 }, null, 2));
+      return;
+    }
+    console.log("Audio logger already running.");
+    return;
+  }
+  const ts = (/* @__PURE__ */ new Date()).toISOString().replace(/[.:]/g, "-").replace("T", "_").slice(0, 19);
+  const output = join(RECORDINGS_DIR, `call-${ts}.wav`);
+  const input = process.env.REX_AUDIO_INPUT || ":0";
+  const args = [
+    "-hide_banner",
+    "-loglevel",
+    "error",
+    "-f",
+    "avfoundation",
+    "-i",
+    input,
+    "-ac",
+    "1",
+    "-ar",
+    "16000",
+    "-y",
+    output
+  ];
+  const child = spawn("ffmpeg", args, {
+    detached: true,
+    stdio: "ignore"
+  });
+  child.unref();
+  const nextState = {
+    pid: child.pid ?? null,
+    startedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    currentFile: output
+  };
+  writeState(nextState);
+  const status = currentStatus();
+  if (jsonMode) {
+    console.log(JSON.stringify({ ok: true, ...status }, null, 2));
+  } else {
+    console.log("Audio logger started.");
+    console.log(`Input: ${input}`);
+    console.log(`Output: ${output}`);
+  }
+}
+function stopCapture(jsonMode) {
+  const state = readState();
+  const wasRunning = isPidRunning(state.pid);
+  if (!state.pid || !wasRunning) {
+    writeState({ pid: null, startedAt: null, currentFile: null });
+    if (jsonMode) {
+      console.log(JSON.stringify({ ok: true, stopped: false, message: "Audio logger already stopped" }, null, 2));
+      return;
+    }
+    console.log("Audio logger already stopped.");
+    return;
+  }
+  try {
+    process.kill(state.pid, "SIGINT");
+  } catch {
+    try {
+      process.kill(state.pid, "SIGTERM");
+    } catch {
+    }
+  }
+  writeState({ pid: null, startedAt: null, currentFile: null });
+  if (jsonMode) {
+    console.log(JSON.stringify({ ok: true, stopped: true, file: state.currentFile }, null, 2));
+  } else {
+    console.log("Audio logger stopped.");
+    if (state.currentFile) console.log(`Saved: ${state.currentFile}`);
+  }
+}
+function printRecordings(jsonMode) {
+  const recordings = listRecordings().map((f) => join(RECORDINGS_DIR, f));
+  if (jsonMode) {
+    console.log(JSON.stringify({ count: recordings.length, recordings }, null, 2));
+    return;
+  }
+  if (recordings.length === 0) {
+    console.log("No recordings yet.");
+    return;
+  }
+  for (const file of recordings) console.log(file);
+}
+async function audio(args) {
+  const sub = args[0] || "status";
+  const jsonMode = args.includes("--json");
+  switch (sub) {
+    case "start":
+      startCapture(jsonMode);
+      return;
+    case "stop":
+      stopCapture(jsonMode);
+      return;
+    case "status":
+      printStatus(currentStatus(), jsonMode);
+      return;
+    case "list":
+      printRecordings(jsonMode);
+      return;
+    default:
+      console.log("Usage: rex audio <start|stop|status|list> [--json]");
+  }
+}
+export {
+  audio
+};

package/dist/audit-ZVTGE4L4.js

@@ -0,0 +1,8 @@
+#!/usr/bin/env node
+import {
+  audit
+} from "./chunk-HAHJD3QH.js";
+import "./chunk-PDX44BCA.js";
+export {
+  audit
+};

package/dist/call-AQZ3Z5SE.js

@@ -0,0 +1,143 @@
+#!/usr/bin/env node
+import "./chunk-PDX44BCA.js";
+
+// src/call.ts
+import { homedir } from "os";
+import { existsSync, mkdirSync, readFileSync } from "fs";
+import { join } from "path";
+import { spawnSync } from "child_process";
+var HOME = homedir();
+var RUNTIME_DIR = join(HOME, ".rex-memory", "runtime");
+var STATE_FILE = join(RUNTIME_DIR, "call-state.json");
+var EVENTS_FILE = join(RUNTIME_DIR, "call-events.jsonl");
+function ensureRuntime() {
+  if (!existsSync(RUNTIME_DIR)) mkdirSync(RUNTIME_DIR, { recursive: true });
+}
+function emptyState() {
+  return {
+    active: false,
+    app: "",
+    reason: "",
+    title: "",
+    startedAt: 0,
+    updatedAt: 0,
+    iso: ""
+  };
+}
+function readState() {
+  try {
+    if (!existsSync(STATE_FILE)) return emptyState();
+    const parsed = JSON.parse(readFileSync(STATE_FILE, "utf-8"));
+    return {
+      active: parsed.active === true,
+      app: typeof parsed.app === "string" ? parsed.app : "",
+      reason: typeof parsed.reason === "string" ? parsed.reason : "",
+      title: typeof parsed.title === "string" ? parsed.title : "",
+      startedAt: typeof parsed.startedAt === "number" ? parsed.startedAt : 0,
+      updatedAt: typeof parsed.updatedAt === "number" ? parsed.updatedAt : 0,
+      iso: typeof parsed.iso === "string" ? parsed.iso : ""
+    };
+  } catch {
+    return emptyState();
+  }
+}
+function printState(jsonMode) {
+  const state = readState();
+  if (jsonMode) {
+    console.log(JSON.stringify(state, null, 2));
+    return;
+  }
+  if (!state.active) {
+    console.log("No active call detected.");
+    return;
+  }
+  console.log(`Active call: ${state.app || "unknown app"}`);
+  if (state.reason) console.log(`Reason: ${state.reason}`);
+  if (state.title) console.log(`Title: ${state.title}`);
+  if (state.startedAt > 0) console.log(`Started: ${new Date(state.startedAt * 1e3).toISOString()}`);
+}
+function printEvents(jsonMode, tail) {
+  if (!existsSync(EVENTS_FILE)) {
+    if (jsonMode) {
+      console.log(JSON.stringify({ events: [] }, null, 2));
+      return;
+    }
+    console.log("No call events yet.");
+    return;
+  }
+  const lines = readFileSync(EVENTS_FILE, "utf-8").split("\n").filter(Boolean);
+  const sliced = tail > 0 ? lines.slice(-tail) : lines;
+  if (jsonMode) {
+    const events = sliced.map((line) => {
+      try {
+        return JSON.parse(line);
+      } catch {
+        return { raw: line };
+      }
+    });
+    console.log(JSON.stringify({ events }, null, 2));
+    return;
+  }
+  for (const line of sliced) console.log(line);
+}
+function selfCommand(args) {
+  const script = process.argv[1];
+  return spawnSync(process.execPath, [script, ...args], { encoding: "utf-8" });
+}
+function runAudioCommand(sub) {
+  selfCommand(["audio", sub]);
+}
+function isAudioCapturing() {
+  const res = selfCommand(["audio", "status", "--json"]);
+  if (res.status !== 0) return false;
+  try {
+    const parsed = JSON.parse((res.stdout || "").trim());
+    return parsed.capturing === true;
+  } catch {
+    return false;
+  }
+}
+async function watchAutoCapture() {
+  ensureRuntime();
+  console.log("REX call watcher daemon started (auto audio logger).");
+  let lastActive = null;
+  while (true) {
+    const state = readState();
+    if (lastActive === null || state.active !== lastActive) {
+      const capturing = isAudioCapturing();
+      if (state.active && !capturing) {
+        runAudioCommand("start");
+        console.log(`[${(/* @__PURE__ */ new Date()).toISOString()}] call_start -> audio start (${state.app || "unknown"})`);
+      }
+      if (!state.active && capturing) {
+        runAudioCommand("stop");
+        console.log(`[${(/* @__PURE__ */ new Date()).toISOString()}] call_end -> audio stop`);
+      }
+      lastActive = state.active;
+    }
+    await new Promise((resolve) => setTimeout(resolve, 5e3));
+  }
+}
+async function call(args) {
+  const sub = args[0] || "status";
+  const jsonMode = args.includes("--json");
+  switch (sub) {
+    case "status":
+      printState(jsonMode);
+      return;
+    case "events": {
+      const tailIndex = args.findIndex((a) => a === "--tail");
+      const tail = tailIndex >= 0 ? parseInt(args[tailIndex + 1] || "20", 10) : 20;
+      printEvents(jsonMode, Number.isFinite(tail) ? tail : 20);
+      return;
+    }
+    case "watch":
+      await watchAutoCapture();
+      return;
+    default:
+      console.log("Usage: rex call <status|events|watch> [--json] [--tail N]");
+  }
+}
+export {
+  call
+};

package/dist/chunk-5ND7JYY3.js

@@ -0,0 +1,62 @@
+#!/usr/bin/env node
+import {
+  DAEMON_LOG_PATH,
+  ensureRexDirs
+} from "./chunk-6SRV2I2H.js";
+
+// src/logger.ts
+import { appendFileSync, existsSync, readFileSync, writeFileSync } from "fs";
+var LEVEL_PRIORITY = { debug: 0, info: 1, warn: 2, error: 3 };
+var LEVEL_LABEL = { debug: "DBG", info: "INF", warn: "WRN", error: "ERR" };
+var LEVEL_COLOR = { debug: "\x1B[2m", info: "\x1B[36m", warn: "\x1B[33m", error: "\x1B[31m" };
+var RESET = "\x1B[0m";
+var minLevel = "info";
+var logToFile = true;
+var logToConsole = true;
+function configureLogger(opts) {
+  if (opts.level) minLevel = opts.level;
+  if (opts.file !== void 0) logToFile = opts.file;
+  if (opts.console !== void 0) logToConsole = opts.console;
+}
+function write(level, source, msg) {
+  if (LEVEL_PRIORITY[level] < LEVEL_PRIORITY[minLevel]) return;
+  const ts = (/* @__PURE__ */ new Date()).toISOString();
+  const label = LEVEL_LABEL[level];
+  const fileLine = `[${ts}] [${label}] [${source}] ${msg}`;
+  if (logToConsole) {
+    const color = LEVEL_COLOR[level];
+    console.log(`${color}[${label}]${RESET} ${RESET}[${source}] ${msg}`);
+  }
+  if (logToFile) {
+    try {
+      ensureRexDirs();
+      appendFileSync(DAEMON_LOG_PATH, fileLine + "\n");
+    } catch {
+    }
+  }
+}
+function createLogger(source) {
+  return {
+    debug: (msg) => write("debug", source, msg),
+    info: (msg) => write("info", source, msg),
+    warn: (msg) => write("warn", source, msg),
+    error: (msg) => write("error", source, msg)
+  };
+}
+function rotateLog(maxLines = 1e4, keepLines = 5e3) {
+  if (!existsSync(DAEMON_LOG_PATH)) return;
+  try {
+    const content = readFileSync(DAEMON_LOG_PATH, "utf-8");
+    const lines = content.split("\n");
+    if (lines.length > maxLines) {
+      writeFileSync(DAEMON_LOG_PATH, lines.slice(-keepLines).join("\n"));
+    }
+  } catch {
+  }
+}
+
+export {
+  configureLogger,
+  createLogger,
+  rotateLog
+};