rex-claude 4.0.0 → 6.0.0

package/dist/hammerspoon/rex-call-watcher.lua

@@ -0,0 +1,186 @@
+-- REX Call Watcher
+-- Detects known voice apps (Discord/Zoom/Meet/Slack/Teams/WhatsApp/FaceTime)
+-- and writes a machine-readable state for local automations.
+
+local M = {}
+
+local HOME = os.getenv("HOME") or ""
+local STATE_PATH = HOME .. "/.rex-memory/runtime/call-state.json"
+local EVENTS_PATH = HOME .. "/.rex-memory/runtime/call-events.jsonl"
+
+local VOICE_APPS = {
+  ["Discord"] = true,
+  ["zoom.us"] = true,
+  ["Microsoft Teams"] = true,
+  ["Slack"] = true,
+  ["WhatsApp"] = true,
+  ["FaceTime"] = true,
+  ["Telegram"] = true,
+}
+
+local BROWSER_APPS = {
+  ["Google Chrome"] = true,
+  ["Arc"] = true,
+  ["Brave Browser"] = true,
+  ["Safari"] = true,
+  ["Microsoft Edge"] = true,
+}
+
+local BROWSER_KEYWORDS = {
+  "google meet",
+  " meet",
+  " huddle",
+  "slack call",
+  "discord",
+  "voice",
+  "call",
+}
+
+local watcher = nil
+local heartbeat = nil
+
+local current = {
+  active = false,
+  app = "",
+  reason = "",
+  title = "",
+  startedAt = 0,
+  updatedAt = 0,
+}
+
+local function ensureRuntimeDir()
+  os.execute('mkdir -p "' .. HOME .. '/.rex-memory/runtime"')
+end
+
+local function writeState(state)
+  ensureRuntimeDir()
+  local f = io.open(STATE_PATH, "w")
+  if not f then return end
+  f:write(hs.json.encode(state))
+  f:close()
+end
+
+local function appendEvent(ev)
+  ensureRuntimeDir()
+  local f = io.open(EVENTS_PATH, "a")
+  if not f then return end
+  f:write(hs.json.encode(ev) .. "\n")
+  f:close()
+end
+
+local function titleLooksLikeCall(title)
+  if not title then return false end
+  local t = string.lower(title)
+  for _, kw in ipairs(BROWSER_KEYWORDS) do
+    if string.find(t, kw, 1, true) then
+      return true
+    end
+  end
+  return false
+end
+
+local function detectCall(appName)
+  if VOICE_APPS[appName] then
+    return true, "voice_app"
+  end
+
+  if BROWSER_APPS[appName] then
+    local win = hs.window.frontmostWindow()
+    local title = win and win:title() or ""
+    if titleLooksLikeCall(title) then
+      return true, "browser_title", title
+    end
+  end
+
+  return false, "", ""
+end
+
+local function updateFromFrontmost()
+  local app = hs.application.frontmostApplication()
+  local appName = app and app:name() or ""
+  local now = os.time()
+  local active, reason, title = detectCall(appName)
+
+  if active and not current.active then
+    current.active = true
+    current.app = appName
+    current.reason = reason
+    current.title = title or ""
+    current.startedAt = now
+    current.updatedAt = now
+
+    appendEvent({
+      type = "call_start",
+      app = current.app,
+      reason = current.reason,
+      title = current.title,
+      timestamp = now,
+      iso = os.date("!%Y-%m-%dT%H:%M:%SZ", now),
+    })
+  elseif active and current.active then
+    current.updatedAt = now
+    if current.app ~= appName then
+      current.app = appName
+      current.reason = reason
+      current.title = title or ""
+    end
+  elseif (not active) and current.active then
+    local duration = math.max(0, now - (current.startedAt or now))
+    appendEvent({
+      type = "call_end",
+      app = current.app,
+      reason = current.reason,
+      title = current.title,
+      duration = duration,
+      startedAt = current.startedAt,
+      endedAt = now,
+      iso = os.date("!%Y-%m-%dT%H:%M:%SZ", now),
+    })
+
+    current.active = false
+    current.app = ""
+    current.reason = ""
+    current.title = ""
+    current.startedAt = 0
+    current.updatedAt = now
+  end
+
+  writeState({
+    active = current.active,
+    app = current.app,
+    reason = current.reason,
+    title = current.title,
+    startedAt = current.startedAt,
+    updatedAt = current.updatedAt,
+    iso = os.date("!%Y-%m-%dT%H:%M:%SZ", now),
+  })
+end
+
+function M.start()
+  if watcher then return end
+
+  watcher = hs.application.watcher.new(function(_, eventType, _)
+    if eventType == hs.application.watcher.activated then
+      updateFromFrontmost()
+    end
+  end)
+  watcher:start()
+
+  -- Keep state fresh even if app title changes without app switch (browser tabs).
+  heartbeat = hs.timer.doEvery(5, updateFromFrontmost)
+  updateFromFrontmost()
+  hs.printf("REX Call Watcher started")
+end
+
+function M.stop()
+  if watcher then
+    watcher:stop()
+    watcher = nil
+  end
+  if heartbeat then
+    heartbeat:stop()
+    heartbeat = nil
+  end
+end
+
+return M

package/dist/index.js

@@ -1,4 +1,12 @@
 #!/usr/bin/env node
+import {
+  configureLogger,
+  createLogger
+} from "./chunk-5ND7JYY3.js";
+import {
+  DAEMON_LOG_PATH
+} from "./chunk-6SRV2I2H.js";
+import "./chunk-PDX44BCA.js";
 
 // ../core/dist/index.js
 import { homedir } from "os";
@@ -286,7 +294,7 @@ async function runAllChecks(claudeDir) {
 }
 
 // src/index.ts
-import { existsSync } from "fs";
+import { existsSync, readFileSync } from "fs";
 import { join as join10 } from "path";
 var COLORS = {
   reset: "\x1B[0m",
@@ -354,8 +362,41 @@ ${thinLine}
 }
 async function main() {
   const command = process.argv[2] ?? "help";
+  const verbose = process.argv.includes("--verbose");
+  if (verbose) configureLogger({ level: "debug" });
+  const log = createLogger("cli");
   switch (command) {
     case "doctor": {
+      const fixMode = process.argv.includes("--fix");
+      if (fixMode) {
+        log.info("Doctor --fix started");
+        console.log(`
+${COLORS.bold}REX Doctor \u2014 Auto-fix mode${COLORS.reset}
+`);
+        const { ensureRexDirs } = await import("./paths-4SECM6E6.js");
+        ensureRexDirs();
+        log.info("Directory structure ensured");
+        console.log(`  ${COLORS.green}\u2713${COLORS.reset} Directory structure ensured`);
+        try {
+          const { migrate } = await import("./migrate-GDO37TI5.js");
+          await migrate();
+        } catch (e) {
+          console.log(`  ${COLORS.yellow}!${COLORS.reset} Migration: ${e.message?.slice(0, 100)}`);
+        }
+        const { execSync: execSync3 } = await import("child_process");
+        try {
+          execSync3("rex ingest", { stdio: "inherit", timeout: 12e4 });
+        } catch {
+        }
+        try {
+          execSync3("rex recategorize --batch=50", { stdio: "inherit", timeout: 18e4 });
+        } catch {
+        }
+        log.info("Auto-fix complete, running doctor");
+        console.log(`
+${COLORS.green}Auto-fix complete.${COLORS.reset} Running doctor...
+`);
+      }
       const report = await runAllChecks();
       console.log(formatReport(report));
       process.exit(report.status === "broken" ? 1 : 0);
@@ -371,10 +412,15 @@ async function main() {
       break;
     }
     case "init": {
-      const { init } = await import("./init-DLFEGD6O.js");
+      const { init } = await import("./init-RDZFIBLA.js");
       await init();
       break;
     }
+    case "install": {
+      const { install } = await import("./install-63JBDPRU.js");
+      await install();
+      break;
+    }
     case "ingest": {
       try {
         const { execSync: execSync3 } = await import("child_process");
@@ -411,20 +457,36 @@ async function main() {
       break;
     }
     case "optimize": {
-      const { optimize } = await import("./optimize-UKMAGQQE.js");
+      const { optimize } = await import("./optimize-5TE5RKZV.js");
       const applyFlag = process.argv.includes("--apply");
-      await optimize(applyFlag);
+      const modelIdx = process.argv.indexOf("--model");
+      const modelFlag = modelIdx !== -1 ? process.argv[modelIdx + 1] : void 0;
+      await optimize(applyFlag, modelFlag);
       break;
     }
     case "prune": {
-      const { prune } = await import("./prune-2PPIVDXK.js");
+      const { prune } = await import("./prune-B7F5B5OF.js");
       const statsFlag = process.argv.includes("--stats");
       await prune(statsFlag);
       break;
     }
     case "setup": {
-      const { setup } = await import("./setup-AO3MW46W.js");
-      await setup();
+      const { setup } = await import("./setup-KNDTVFO6.js");
+      const nonInteractive = process.argv.includes("--yes") || process.argv.includes("--non-interactive");
+      const skipTelegram = process.argv.includes("--skip-telegram");
+      await setup({ nonInteractive, skipTelegram, autoInstallDeps: nonInteractive });
+      break;
+    }
+    case "audit": {
+      const { audit } = await import("./audit-ZVTGE4L4.js");
+      const json = process.argv.includes("--json");
+      const strict = process.argv.includes("--strict");
+      await audit({ json, strict });
+      break;
+    }
+    case "migrate": {
+      const { migrate } = await import("./migrate-GDO37TI5.js");
+      await migrate();
       break;
     }
     case "llm": {
@@ -433,35 +495,203 @@ async function main() {
         console.error("Usage: rex llm <prompt>");
         process.exit(1);
       }
-      const { llm } = await import("./llm-YRORUH7E.js");
+      const { llm } = await import("./llm-RALIPIMI.js");
       const result = await llm(prompt);
       console.log(result);
       break;
     }
     case "context": {
       const targetPath = process.argv[3] || process.cwd();
-      const { context } = await import("./context-FN5O5YBI.js");
+      const { context } = await import("./context-XNCG2M5Q.js");
       await context(targetPath);
       break;
     }
     case "gateway": {
-      const { gateway } = await import("./gateway-EKMU5D7J.js");
+      const { gateway } = await import("./gateway-YLP66MCQ.js");
       await gateway();
       break;
     }
+    case "app": {
+      const { app } = await import("./app-3VWDSH5F.js");
+      await app(process.argv.slice(3));
+      break;
+    }
+    case "update": {
+      const { app } = await import("./app-3VWDSH5F.js");
+      await app(["update", ...process.argv.slice(3)]);
+      break;
+    }
+    case "agents": {
+      const { agents } = await import("./agents-JIZXXASP.js");
+      await agents(process.argv.slice(3));
+      break;
+    }
+    case "skills": {
+      const { skills } = await import("./skills-AIWFY5NH.js");
+      await skills(process.argv.slice(3));
+      break;
+    }
+    case "mcp": {
+      const { mcpRegistry } = await import("./mcp_registry-DX4GGSP6.js");
+      await mcpRegistry(process.argv.slice(3));
+      break;
+    }
+    case "audio": {
+      const { audio } = await import("./audio-US2J627E.js");
+      await audio(process.argv.slice(3));
+      break;
+    }
+    case "call": {
+      const { call } = await import("./call-AQZ3Z5SE.js");
+      await call(process.argv.slice(3));
+      break;
+    }
+    case "voice": {
+      const { voice } = await import("./voice-RITC3EVC.js");
+      await voice(process.argv.slice(3));
+      break;
+    }
     case "startup": {
-      const { installStartup } = await import("./init-DLFEGD6O.js");
+      const { installStartup } = await import("./init-RDZFIBLA.js");
       installStartup();
       break;
     }
     case "startup-remove": {
-      const { uninstallStartup } = await import("./init-DLFEGD6O.js");
+      const { uninstallStartup } = await import("./init-RDZFIBLA.js");
       uninstallStartup();
       break;
     }
+    case "categorize": {
+      try {
+        const memDir = findMemoryPackage();
+        if (!memDir) {
+          console.log(`Memory package not found. Run from the REX monorepo.`);
+          process.exit(1);
+        }
+        const { execSync: execSync3 } = await import("child_process");
+        const modelArg = process.argv.find((a) => a.startsWith("--model=")) ?? (process.argv.includes("--model") ? `--model=${process.argv[process.argv.indexOf("--model") + 1]}` : "");
+        const batchArg = process.argv.find((a) => a.startsWith("--batch=")) ?? (process.argv.includes("--batch") ? `--batch=${process.argv[process.argv.indexOf("--batch") + 1]}` : "");
+        execSync3(`npx tsx src/categorize.ts ${modelArg} ${batchArg}`.trim(), { cwd: memDir, stdio: "inherit" });
+      } catch {
+        process.exit(1);
+      }
+      break;
+    }
+    case "list-memories": {
+      try {
+        const memDir = findMemoryPackage();
+        if (!memDir) {
+          console.log(`Memory package not found.`);
+          process.exit(1);
+        }
+        const { execSync: execSync3 } = await import("child_process");
+        const extraArgs = process.argv.slice(3).join(" ");
+        execSync3(`npx tsx src/categorize.ts list ${extraArgs}`.trim(), { cwd: memDir, stdio: "inherit" });
+      } catch {
+        process.exit(1);
+      }
+      break;
+    }
+    case "consolidate": {
+      try {
+        const memDir = findMemoryPackage();
+        if (!memDir) {
+          console.log(`Memory package not found. Run from the REX monorepo.`);
+          process.exit(1);
+        }
+        const { execSync: execSync3 } = await import("child_process");
+        const thresholdArg = process.argv.find((a) => a.startsWith("--threshold=")) ?? "";
+        const limitArg = process.argv.find((a) => a.startsWith("--limit=")) ?? "";
+        const modelArg = process.argv.find((a) => a.startsWith("--model=")) ?? "";
+        const dryRunArg = process.argv.includes("--dry-run") ? "--dry-run" : "";
+        execSync3(`npx tsx src/categorize.ts consolidate ${thresholdArg} ${limitArg} ${modelArg} ${dryRunArg}`.trim(), { cwd: memDir, stdio: "inherit" });
+      } catch {
+        process.exit(1);
+      }
+      break;
+    }
+    case "models": {
+      const { showModelRouter } = await import("./router-2JD34COX.js");
+      await showModelRouter();
+      break;
+    }
+    case "projects": {
+      const { scanProjects, saveProjectIndex } = await import("./projects-V6TSLO7E.js");
+      console.log(`${COLORS.cyan}Scanning projects...${COLORS.reset}`);
+      const projects = scanProjects();
+      saveProjectIndex(projects);
+      console.log(`
+${COLORS.bold}${projects.length} projects found${COLORS.reset}
+`);
+      for (const p of projects) {
+        const dot = p.status === "active" ? `${COLORS.green}\u25CF${COLORS.reset}` : `${COLORS.dim}\u25CB${COLORS.reset}`;
+        console.log(`  ${dot} ${COLORS.bold}${p.name.padEnd(20)}${COLORS.reset} ${p.stack.join(", ").padEnd(30)} ${COLORS.dim}${p.lastActive}${COLORS.reset}`);
+      }
+      break;
+    }
+    case "recategorize": {
+      const { recategorize } = await import("./recategorize-YXYIMQLZ.js");
+      const batchArg = process.argv.find((a) => a.startsWith("--batch="));
+      const batch = batchArg ? parseInt(batchArg.split("=")[1]) : 50;
+      const dryRun = process.argv.includes("--dry-run");
+      await recategorize({ batch, dryRun });
+      break;
+    }
+    case "preload": {
+      const { preload } = await import("./preload-I3MYBVNU.js");
+      const cwd = process.argv[3] || process.cwd();
+      const context = await preload(cwd);
+      if (context) console.log(context);
+      break;
+    }
+    case "self-review": {
+      const { selfReview } = await import("./self-improve-YK7RCYF4.js");
+      await selfReview();
+      break;
+    }
+    case "promote-rule": {
+      const { promoteRule } = await import("./self-improve-YK7RCYF4.js");
+      const idx = parseInt(process.argv[3]);
+      if (!idx) {
+        console.log("Usage: rex promote-rule <index>");
+        process.exit(1);
+      }
+      const ok = await promoteRule(idx);
+      console.log(ok ? `${COLORS.green}Rule promoted to ~/.claude/rules/${COLORS.reset}` : `${COLORS.red}Failed \u2014 invalid index or no suggested rule${COLORS.reset}`);
+      break;
+    }
+    case "daemon": {
+      const { daemon } = await import("./daemon-5KNSNFTD.js");
+      await daemon();
+      break;
+    }
+    case "logs": {
+      const lines = process.argv.find((a) => a.startsWith("--lines="));
+      const n = lines ? parseInt(lines.split("=")[1]) : 50;
+      const follow = process.argv.includes("--follow") || process.argv.includes("-f");
+      if (!existsSync(DAEMON_LOG_PATH)) {
+        console.log(`${COLORS.dim}No log file found at ${DAEMON_LOG_PATH}${COLORS.reset}`);
+        break;
+      }
+      if (follow) {
+        const { execSync: execSyncLocal } = await import("child_process");
+        try {
+          execSyncLocal(`tail -f "${DAEMON_LOG_PATH}"`, { stdio: "inherit" });
+        } catch {
+        }
+      } else {
+        const content = readFileSync(DAEMON_LOG_PATH, "utf-8");
+        const logLines = content.split("\n").filter(Boolean);
+        const tail = logLines.slice(-n);
+        for (const line of tail) console.log(line);
+        console.log(`
+${COLORS.dim}Showing last ${tail.length} of ${logLines.length} lines. Use --follow/-f for live tail.${COLORS.reset}`);
+      }
+      break;
+    }
     case "--version":
     case "-v":
-      console.log("rex-claude v4.0.0");
+      console.log("rex-claude v6.0.0");
       break;
     case "help":
     default:
@@ -469,33 +699,96 @@ async function main() {
 ${COLORS.bold}REX${COLORS.reset} \u2014 Claude Code sous steroides
 
 ${COLORS.bold}Commands:${COLORS.reset}
+  rex install         One-command setup (init + setup + audit)
   rex init            Setup REX (guards, hooks, MCP, startup)
+  rex audit           Run integration audit checks
   rex doctor          Full health check (9 categories)
+  rex doctor --fix    Auto-fix common issues then check
   rex status          Quick one-line status
   rex startup         Install LaunchAgent (auto-start on login)
   rex startup-remove  Remove LaunchAgent
 
 ${COLORS.bold}Memory (requires Ollama):${COLORS.reset}
+  rex migrate          Migrate ~/.rex-memory/ to ~/.claude/rex/ hub
   rex ingest           Sync session history to vector DB
   rex search <query>   Semantic search across past sessions
+  rex categorize       Classify uncategorized memories
+  rex consolidate      Merge similar memories (cosine clustering)
+  rex recategorize     Re-classify session memories with AI
   rex optimize         Analyze CLAUDE.md with local LLM
   rex optimize --apply Apply optimizations (with backup)
   rex prune            Cleanup old/duplicate memories
   rex prune --stats    Show memory database stats
+  rex self-review      Extract lessons, detect error patterns
+  rex promote-rule N   Promote rule candidate to ~/.claude/rules/
 
 ${COLORS.bold}LLM & Context:${COLORS.reset}
-  rex setup            Install Ollama + models + Telegram gateway
+  rex setup            Install Ollama + models + Telegram gateway (interactive)
+  rex setup --yes      Non-interactive setup (auto-install deps, env-based Telegram)
   rex llm <prompt>     Query local LLM directly
+  rex models           Show task-aware model routing table
+  rex preload [path]   Show pre-loaded context for a path
   rex context [path]   Analyze project, recommend MCP/skills
+  rex projects         Scan and index all dev projects
+
+${COLORS.bold}Background:${COLORS.reset}
+  rex daemon           Start persistent background daemon
+  rex logs             Show recent daemon/CLI logs (--lines=N, --follow/-f)
 
 ${COLORS.bold}Telegram Gateway:${COLORS.reset}
   rex gateway          Start Telegram bot (long-polling, interactive)
 
+${COLORS.bold}App:${COLORS.reset}
+  rex app update [--debug|--release] [--no-launch]
+                     Build + install + relaunch app from current repo
+  rex app info        Show installed app path + source repo/commit
+  rex app open        Open installed app
+  rex update          Alias for: rex app update
+
+${COLORS.bold}Autonomous Agents:${COLORS.reset}
+  rex agents profiles          List built-in agent profiles
+  rex agents create <profile>  Create agent (read/analysis/code-review/advanced/ultimate)
+  rex agents run <id>          Start autonomous loop (daemon)
+  rex agents run <id> --once   Run one cycle only
+  rex agents stop <id>         Stop running agent
+  rex agents status [id]       Show status
+  rex agents logs <id>         Tail logs
+  rex agents chat <message>   Chat with orchestrator
+  rex agents team [name]      List teams / team members
+
+${COLORS.bold}Skills:${COLORS.reset}
+  rex skills list              List installed skills
+  rex skills show <name>       Show skill content
+  rex skills add <name>        Create a new skill
+  rex skills delete <name>     Remove a skill
+
+${COLORS.bold}MCP Registry:${COLORS.reset}
+  rex mcp list                 List MCP servers
+  rex mcp add <name> ...       Add stdio MCP server
+  rex mcp add-url <name> <url> Add remote MCP server (sse/http)
+  rex mcp check <id>           Check MCP connectivity
+  rex mcp discover <id|name>   List tools exposed by an MCP server
+  rex mcp search <query>       Search MCP marketplace cache
+  rex mcp install <name>       Install MCP server from marketplace
+  rex mcp sync-claude          Sync enabled stdio servers to ~/.claude/settings.json
+
+${COLORS.bold}Voice & Calls:${COLORS.reset}
+  rex call status             Current call detection status (Hammerspoon)
+  rex call events --tail 20   Recent call start/end events
+  rex call watch              Auto start/stop audio logger from call events
+  rex voice status            Voice pipeline status (whisper + optimize)
+  rex voice set-optimize on   Enable post-transcript optimize
+  rex voice transcribe        Transcribe latest WAV recording
+  rex audio status            Audio logger status
+  rex audio start             Start audio capture (ffmpeg avfoundation)
+  rex audio stop              Stop audio capture
+  rex audio list              List saved recordings
+
 ${COLORS.bold}Info:${COLORS.reset}
   rex help             Show this help
   rex --version        Show version
 
-${COLORS.dim}After install: rex init && rex setup \u2014 everything else is automatic.${COLORS.reset}
+${COLORS.dim}After install: rex install \u2014 everything else is automatic.${COLORS.reset}
 `);
   }
 }
@@ -503,6 +796,7 @@ function findMemoryPackage() {
   const thisDir = new URL(".", import.meta.url).pathname;
   const candidates = [
     join10(thisDir, "..", "..", "memory"),
+    join10(process.env.HOME || "~", "Documents", "Developer", "keiy", "rex", "packages", "memory"),
     join10(process.env.HOME || "~", ".rex-memory")
   ];
   for (const c of candidates) {

package/dist/init-RDZFIBLA.js

@@ -0,0 +1,30 @@
+#!/usr/bin/env node
+import {
+  init,
+  installApp,
+  installCallWatchAgent,
+  installDaemonAgent,
+  installGatewayAgent,
+  installHammerspoonCallWatcher,
+  installIngestAgent,
+  installStartup,
+  uninstallCallWatchAgent,
+  uninstallGatewayAgent,
+  uninstallIngestAgent,
+  uninstallStartup
+} from "./chunk-KR7ISYZH.js";
+import "./chunk-PDX44BCA.js";
+export {
+  init,
+  installApp,
+  installCallWatchAgent,
+  installDaemonAgent,
+  installGatewayAgent,
+  installHammerspoonCallWatcher,
+  installIngestAgent,
+  installStartup,
+  uninstallCallWatchAgent,
+  uninstallGatewayAgent,
+  uninstallIngestAgent,
+  uninstallStartup
+};

package/dist/install-63JBDPRU.js

@@ -0,0 +1,41 @@
+#!/usr/bin/env node
+import {
+  init
+} from "./chunk-KR7ISYZH.js";
+import {
+  setup
+} from "./chunk-A7ZLQUOX.js";
+import {
+  audit
+} from "./chunk-HAHJD3QH.js";
+import "./chunk-PDX44BCA.js";
+
+// src/install.ts
+var COLORS = {
+  reset: "\x1B[0m",
+  green: "\x1B[32m",
+  bold: "\x1B[1m",
+  dim: "\x1B[2m"
+};
+async function install() {
+  const line = "\u2550".repeat(45);
+  console.log(`
+${line}`);
+  console.log(`${COLORS.bold}        REX INSTALL \u2014 One Command${COLORS.reset}`);
+  console.log(`${line}
+`);
+  await init();
+  await setup({
+    nonInteractive: true,
+    autoInstallDeps: true,
+    skipTelegram: process.env.REX_SKIP_TELEGRAM === "1"
+  });
+  console.log(`
+${COLORS.dim}Running post-install audit...${COLORS.reset}`);
+  await audit();
+  console.log(`
+${COLORS.green}${COLORS.bold}REX install complete.${COLORS.reset}`);
+}
+export {
+  install
+};