rex-claude 2.2.0 → 3.0.0

package/dist/chunk-7AGI43F5.js

@@ -0,0 +1,42 @@
+#!/usr/bin/env node
+
+// src/llm.ts
+var OLLAMA_URL = process.env.OLLAMA_URL || "http://localhost:11434";
+var PREFERRED_MODELS = ["qwen3.5:9b", "qwen3.5:4b", "qwen2.5:1.5b", "llama3.2", "mistral"];
+async function detectModel() {
+  if (process.env.REX_LLM_MODEL) return process.env.REX_LLM_MODEL;
+  try {
+    const res = await fetch(`${OLLAMA_URL}/api/tags`);
+    const data = await res.json();
+    const available = data.models.map((m) => m.name);
+    for (const pref of PREFERRED_MODELS) {
+      const base = pref.split(":")[0];
+      const match = available.find((a) => a.includes(base));
+      if (match) return match;
+    }
+    return available.find((a) => !a.includes("embed")) || available[0];
+  } catch {
+    return "qwen3.5:4b";
+  }
+}
+async function llm(prompt, system, model) {
+  const useModel = model || await detectModel();
+  const res = await fetch(`${OLLAMA_URL}/api/generate`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({
+      model: useModel,
+      prompt,
+      system,
+      stream: false
+    })
+  });
+  if (!res.ok) throw new Error(`Ollama generate failed: ${res.status}`);
+  const data = await res.json();
+  return data.response;
+}
+
+export {
+  detectModel,
+  llm
+};

package/dist/context-FN5O5YBI.js

@@ -0,0 +1,114 @@
+#!/usr/bin/env node
+
+// src/context.ts
+import { existsSync, readFileSync } from "fs";
+import { join, basename } from "path";
+var COLORS = {
+  reset: "\x1B[0m",
+  green: "\x1B[32m",
+  yellow: "\x1B[33m",
+  bold: "\x1B[1m",
+  dim: "\x1B[2m",
+  cyan: "\x1B[36m"
+};
+function detectStack(projectPath) {
+  const pkgPath = join(projectPath, "package.json");
+  const pkg = existsSync(pkgPath) ? JSON.parse(readFileSync(pkgPath, "utf-8")) : {};
+  const deps = { ...pkg.dependencies, ...pkg.devDependencies };
+  const stacks = [
+    {
+      name: "Next.js",
+      detected: !!deps?.next,
+      mcpServers: ["next-devtools"],
+      skills: ["build-validate", "one-shot"]
+    },
+    {
+      name: "React",
+      detected: !!deps?.react,
+      mcpServers: [],
+      skills: ["figma-workflow", "dstudio-design-system"]
+    },
+    {
+      name: "Tailwind",
+      detected: !!deps?.tailwindcss || !!deps?.["@tailwindcss/vite"],
+      mcpServers: [],
+      skills: ["figma-workflow"]
+    },
+    {
+      name: "Playwright",
+      detected: !!deps?.["@playwright/test"] || !!deps?.playwright,
+      mcpServers: ["playwright"],
+      skills: []
+    },
+    {
+      name: "Cloudflare Workers",
+      detected: !!deps?.wrangler || existsSync(join(projectPath, "wrangler.toml")),
+      mcpServers: [],
+      skills: ["deploy-checklist"]
+    },
+    {
+      name: "Flutter",
+      detected: existsSync(join(projectPath, "pubspec.yaml")),
+      mcpServers: [],
+      skills: []
+    },
+    {
+      name: "CakePHP",
+      detected: existsSync(join(projectPath, "composer.json")) && readFileSync(join(projectPath, "composer.json"), "utf-8").includes("cakephp"),
+      mcpServers: [],
+      skills: []
+    }
+  ];
+  return stacks;
+}
+async function context(targetPath) {
+  const line = "\u2550".repeat(45);
+  console.log(`
+${line}`);
+  console.log(`${COLORS.bold}        REX CONTEXT${COLORS.reset}`);
+  console.log(`${line}
+`);
+  const absPath = join(process.cwd(), targetPath === "." ? "" : targetPath);
+  const projectName = basename(absPath);
+  console.log(`  ${COLORS.cyan}Project:${COLORS.reset} ${projectName}`);
+  console.log(`  ${COLORS.cyan}Path:${COLORS.reset} ${absPath}
+`);
+  const stacks = detectStack(absPath);
+  const detected = stacks.filter((s) => s.detected);
+  if (detected.length === 0) {
+    console.log(`  ${COLORS.yellow}No known stack detected.${COLORS.reset}`);
+    console.log();
+    return;
+  }
+  console.log(`  ${COLORS.bold}Detected stack:${COLORS.reset}`);
+  for (const s of detected) {
+    console.log(`    ${COLORS.green}\u2713${COLORS.reset} ${s.name}`);
+  }
+  const recommendedMcp = [...new Set(detected.flatMap((s) => s.mcpServers))];
+  const recommendedSkills = [...new Set(detected.flatMap((s) => s.skills))];
+  if (recommendedMcp.length > 0) {
+    console.log(`
+  ${COLORS.bold}Recommended MCP servers:${COLORS.reset}`);
+    for (const mcp of recommendedMcp) {
+      console.log(`    ${COLORS.cyan}\u2192${COLORS.reset} ${mcp}`);
+    }
+  }
+  if (recommendedSkills.length > 0) {
+    console.log(`
+  ${COLORS.bold}Recommended skills:${COLORS.reset}`);
+    for (const skill of recommendedSkills) {
+      console.log(`    ${COLORS.cyan}\u2192${COLORS.reset} ${skill}`);
+    }
+  }
+  const hasClaudeMd = existsSync(join(absPath, "CLAUDE.md"));
+  if (!hasClaudeMd) {
+    console.log(`
+  ${COLORS.yellow}!${COLORS.reset} No project CLAUDE.md found \u2014 consider running ${COLORS.cyan}/project-init${COLORS.reset}`);
+  }
+  console.log(`
+${COLORS.dim}\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500${COLORS.reset}
+`);
+}
+export {
+  context
+};

package/dist/gateway-EOVQXRON.js

@@ -0,0 +1,198 @@
+#!/usr/bin/env node
+
+// src/gateway.ts
+import { homedir } from "os";
+import { readFileSync } from "fs";
+import { join } from "path";
+import { execSync } from "child_process";
+var COLORS = {
+  reset: "\x1B[0m",
+  green: "\x1B[32m",
+  yellow: "\x1B[33m",
+  red: "\x1B[31m",
+  dim: "\x1B[2m",
+  bold: "\x1B[1m",
+  cyan: "\x1B[36m"
+};
+function getCredentials() {
+  const settingsPath = join(homedir(), ".claude", "settings.json");
+  try {
+    const settings = JSON.parse(readFileSync(settingsPath, "utf-8"));
+    const token2 = settings.env?.REX_TELEGRAM_BOT_TOKEN;
+    const chatId2 = settings.env?.REX_TELEGRAM_CHAT_ID;
+    if (token2 && chatId2) return { token: token2, chatId: chatId2 };
+  } catch {
+  }
+  const token = process.env.REX_TELEGRAM_BOT_TOKEN;
+  const chatId = process.env.REX_TELEGRAM_CHAT_ID;
+  if (token && chatId) return { token, chatId };
+  return null;
+}
+async function sendMessage(token, chatId, text, parseMode = "Markdown") {
+  try {
+    await fetch(`https://api.telegram.org/bot${token}/sendMessage`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ chat_id: chatId, text, parse_mode: parseMode })
+    });
+  } catch {
+  }
+}
+function runCommand(cmd) {
+  try {
+    return execSync(cmd, { timeout: 3e4, encoding: "utf-8" }).trim();
+  } catch (e) {
+    return e.stderr?.trim() || e.message || "Command failed";
+  }
+}
+async function handleCommand(text) {
+  const cmd = text.trim().toLowerCase();
+  if (cmd === "/status" || cmd === "/s") {
+    const out = runCommand("rex status");
+    return out || "REX status unavailable";
+  }
+  if (cmd === "/doctor" || cmd === "/d") {
+    const out = runCommand("rex doctor");
+    return out.replace(/\x1b\[[0-9;]*m/g, "").slice(0, 4e3);
+  }
+  if (cmd === "/ingest" || cmd === "/i") {
+    const out = runCommand("rex ingest");
+    return `*Ingest*
+\`\`\`
+${out.slice(0, 3e3)}
+\`\`\``;
+  }
+  if (cmd.startsWith("/search ") || cmd.startsWith("/q ")) {
+    const query = text.replace(/^\/(search|q)\s+/i, "");
+    if (!query) return "Usage: /search <query>";
+    const out = runCommand(`rex search ${query}`);
+    return out ? `*Search:* ${query}
+\`\`\`
+${out.slice(0, 3e3)}
+\`\`\`` : "No results";
+  }
+  if (cmd.startsWith("/llm ") || cmd.startsWith("/ask ")) {
+    const prompt = text.replace(/^\/(llm|ask)\s+/i, "");
+    if (!prompt) return "Usage: /llm <prompt>";
+    const out = runCommand(`rex llm "${prompt.replace(/"/g, '\\"')}"`);
+    return out.slice(0, 4e3);
+  }
+  if (cmd === "/optimize" || cmd === "/o") {
+    const out = runCommand("rex optimize");
+    return `*Optimize*
+\`\`\`
+${out.replace(/\x1b\[[0-9;]*m/g, "").slice(0, 3e3)}
+\`\`\``;
+  }
+  if (cmd === "/git" || cmd === "/g") {
+    const branch = runCommand('git branch --show-current 2>/dev/null || echo "n/a"');
+    const status = runCommand("git status --short 2>/dev/null | head -15");
+    const lastCommit = runCommand('git log -1 --format="%s" 2>/dev/null || echo "n/a"');
+    return `*Git*
+Branch: \`${branch}\`
+Last: ${lastCommit}
+\`\`\`
+${status || "Clean"}
+\`\`\``;
+  }
+  if (cmd.startsWith("/sh ") || cmd.startsWith("/run ")) {
+    const shellCmd = text.replace(/^\/(sh|run)\s+/i, "");
+    const blocked = ["rm -rf", "rm -r /", "mkfs", "dd if=", ":(){", "chmod -R 777", "git push --force main", "git push --force master"];
+    if (blocked.some((b) => shellCmd.toLowerCase().includes(b))) {
+      return "Blocked: dangerous command";
+    }
+    const out = runCommand(shellCmd);
+    return `\`$ ${shellCmd}\`
+\`\`\`
+${out.slice(0, 3500)}
+\`\`\``;
+  }
+  if (cmd === "/help" || cmd === "/start" || cmd === "/h") {
+    return `*REX Gateway*
+\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501
+/status \u2014 Quick health check
+/doctor \u2014 Full diagnostics
+/ingest \u2014 Sync sessions to memory
+/search <q> \u2014 Semantic search
+/llm <prompt> \u2014 Ask local LLM
+/optimize \u2014 Analyze CLAUDE.md
+/git \u2014 Git status
+/sh <cmd> \u2014 Run shell command
+/help \u2014 This message`;
+  }
+  if (text.length > 3) {
+    try {
+      const check = await fetch("http://localhost:11434/api/tags");
+      if (check.ok) {
+        const out = runCommand(`rex llm "${text.replace(/"/g, '\\"')}"`);
+        if (out && !out.includes("rex-claude") && !out.includes("Commands:")) {
+          return out.slice(0, 4e3);
+        }
+      }
+    } catch {
+    }
+    return `Unknown command: "${text.slice(0, 50)}"
+Send /help for available commands.`;
+  }
+  return "Send /help for available commands.";
+}
+async function gateway() {
+  const creds = getCredentials();
+  if (!creds) {
+    console.error(`${COLORS.red}No Telegram credentials found.${COLORS.reset}`);
+    console.error(`Run ${COLORS.cyan}rex setup${COLORS.reset} to configure Telegram gateway.`);
+    process.exit(1);
+  }
+  const { token, chatId } = creds;
+  console.log(`${COLORS.bold}REX Gateway${COLORS.reset} \u2014 Telegram long-polling active`);
+  console.log(`${COLORS.dim}Bot token: ...${token.slice(-8)}${COLORS.reset}`);
+  console.log(`${COLORS.dim}Chat ID: ${chatId}${COLORS.reset}`);
+  console.log(`${COLORS.dim}Press Ctrl+C to stop${COLORS.reset}
+`);
+  let offset = 0;
+  try {
+    const flush = await fetch(`https://api.telegram.org/bot${token}/getUpdates?offset=-1`);
+    const flushData = await flush.json();
+    if (flushData.result?.length) {
+      offset = flushData.result[flushData.result.length - 1].update_id + 1;
+    }
+  } catch {
+  }
+  await sendMessage(token, chatId, "\u{1F7E2} *REX Gateway* started\nSend /help for commands.");
+  const POLL_TIMEOUT = 30;
+  process.on("SIGINT", async () => {
+    console.log(`
+${COLORS.dim}Shutting down...${COLORS.reset}`);
+    await sendMessage(token, chatId, "\u{1F534} *REX Gateway* stopped");
+    process.exit(0);
+  });
+  while (true) {
+    try {
+      const res = await fetch(
+        `https://api.telegram.org/bot${token}/getUpdates?offset=${offset}&timeout=${POLL_TIMEOUT}&allowed_updates=["message"]`
+      );
+      const data = await res.json();
+      if (!data.ok || !data.result?.length) continue;
+      for (const update of data.result) {
+        offset = update.update_id + 1;
+        const msg = update.message;
+        if (!msg?.text) continue;
+        if (String(msg.chat.id) !== chatId) {
+          console.log(`${COLORS.yellow}Ignored message from chat ${msg.chat.id}${COLORS.reset}`);
+          continue;
+        }
+        const from = msg.from?.username ?? "?";
+        console.log(`${COLORS.cyan}@${from}${COLORS.reset}: ${msg.text}`);
+        const reply = await handleCommand(msg.text);
+        await sendMessage(token, chatId, reply);
+        console.log(`${COLORS.green}\u2192${COLORS.reset} ${reply.slice(0, 80)}...`);
+      }
+    } catch (err) {
+      console.error(`${COLORS.red}Poll error:${COLORS.reset} ${err.message}`);
+      await new Promise((r) => setTimeout(r, 5e3));
+    }
+  }
+}
+export {
+  gateway
+};

package/dist/guards/completion-guard.sh

@@ -5,14 +5,27 @@
 
 # Check for TODO/placeholder/stub patterns in recently modified files
 MODIFIED_FILES=$(git diff --name-only HEAD 2>/dev/null)
-if [ -z "$MODIFIED_FILES" ]; then
+STAGED_FILES=$(git diff --cached --name-only 2>/dev/null)
+UNTRACKED_FILES=$(git ls-files --others --exclude-standard 2>/dev/null)
+
+ALL_FILES=$(echo -e "${MODIFIED_FILES}\n${STAGED_FILES}\n${UNTRACKED_FILES}" | sort -u | grep -v '^$')
+
+if [ -z "$ALL_FILES" ]; then
   exit 0
 fi
 
 ISSUES=""
 
+# Warn about untracked files that should probably be committed
+if [ -n "$UNTRACKED_FILES" ]; then
+  UNTRACKED_CODE=$(echo "$UNTRACKED_FILES" | grep -E '\.(ts|tsx|js|jsx|py|rs|go|sh|css|html|vue|svelte)$' | head -5)
+  if [ -n "$UNTRACKED_CODE" ]; then
+    ISSUES="${ISSUES}\n⚠ Untracked code files (forgot to git add?):\n${UNTRACKED_CODE}\n"
+  fi
+fi
+
 # Check for incomplete implementation markers
-for file in $MODIFIED_FILES; do
+for file in $ALL_FILES; do
   if [ ! -f "$file" ]; then continue; fi
 
   # Skip non-code files

package/dist/guards/dangerous-cmd-guard.sh

@@ -3,8 +3,8 @@
 # Hook: PreToolUse (matcher: Bash)
 # Prevents destructive commands from running without confirmation
 
-# $TOOL_INPUT contains the command about to be executed
-CMD="$TOOL_INPUT"
+# $CLAUDE_TOOL_INPUT contains the command about to be executed
+CMD="${CLAUDE_TOOL_INPUT:-$TOOL_INPUT}"
 
 # Patterns that should ALWAYS be blocked or warned
 BLOCKED_PATTERNS=(

package/dist/guards/error-pattern-guard.sh

@@ -0,0 +1,45 @@
+#!/bin/bash
+# REX Guard: Error Pattern Detector
+# Hook: PostToolUse (matcher: Bash)
+# Detects recurring error patterns in command output and suggests creating rules
+
+TRACK_FILE="${HOME}/.claude/rex-error-patterns.json"
+TOOL_OUTPUT="${CLAUDE_TOOL_OUTPUT:-$TOOL_OUTPUT}"
+
+# Only process if there's output that looks like an error
+if [ -z "$TOOL_OUTPUT" ]; then
+  exit 0
+fi
+
+# Extract error-like lines from output
+ERRORS=$(echo "$TOOL_OUTPUT" | grep -iE '(error|ERR!|fatal|failed|ENOENT|EACCES|TypeError|SyntaxError|ReferenceError|Cannot find|Module not found|command not found)' | head -3)
+
+if [ -z "$ERRORS" ]; then
+  exit 0
+fi
+
+# Normalize error to a pattern (strip file paths, line numbers, specific values)
+PATTERN=$(echo "$ERRORS" | head -1 | sed 's/[0-9]\+/N/g' | sed 's|/[^ ]*||g' | sed 's/"[^"]*"/"..."/g' | cut -c1-100)
+
+if [ -z "$PATTERN" ]; then
+  exit 0
+fi
+
+# Initialize tracking file if needed
+if [ ! -f "$TRACK_FILE" ]; then
+  echo '{}' > "$TRACK_FILE"
+fi
+
+# Count occurrences of this pattern (using simple grep since jq may not be available)
+COUNT=$(grep -c "$PATTERN" "$TRACK_FILE" 2>/dev/null || echo "0")
+NEWCOUNT=$((COUNT + 1))
+
+# Append pattern to tracking file
+echo "{\"pattern\":\"$PATTERN\",\"timestamp\":\"$(date -u +%Y-%m-%dT%H:%M:%SZ)\"}" >> "$TRACK_FILE"
+
+# After 3 occurrences, suggest creating a rule
+if [ "$NEWCOUNT" -ge 3 ]; then
+  echo "REX Guard: Recurring error detected ($NEWCOUNT times): $PATTERN"
+  echo "Consider using /new-rule to create a permanent rule for this pattern."
+  echo "Call rex_learn with category 'lesson' to memorize: \"Recurring error: $PATTERN\""
+fi

package/dist/guards/notify-telegram.sh

@@ -0,0 +1,34 @@
+#!/bin/bash
+# REX Guard: Telegram Notification on task completion
+# Hook: Stop — fires when Claude finishes working
+# Sends a short summary to Telegram for traceability
+
+TELEGRAM_BOT_TOKEN="${REX_TELEGRAM_BOT_TOKEN:-}"
+TELEGRAM_CHAT_ID="${REX_TELEGRAM_CHAT_ID:-}"
+
+# Skip if not configured
+if [ -z "$TELEGRAM_BOT_TOKEN" ] || [ -z "$TELEGRAM_CHAT_ID" ]; then
+  exit 0
+fi
+
+# Build summary from git state
+BRANCH=$(git branch --show-current 2>/dev/null || echo "n/a")
+PROJECT=$(basename "$(git rev-parse --show-toplevel 2>/dev/null || pwd)")
+MODIFIED=$(git diff --name-only HEAD 2>/dev/null | wc -l | tr -d ' ')
+STAGED=$(git diff --cached --name-only 2>/dev/null | wc -l | tr -d ' ')
+LAST_COMMIT=$(git log -1 --format="%s" 2>/dev/null || echo "n/a")
+TIMESTAMP=$(date +"%H:%M")
+
+# Compose message
+MSG="✅ *REX — Task Done*
+━━━━━━━━━━━━━━
+📁 \`${PROJECT}\` → \`${BRANCH}\`
+📝 ${MODIFIED} modified, ${STAGED} staged
+💬 ${LAST_COMMIT}
+🕐 ${TIMESTAMP}"
+
+# Send (fire-and-forget, no blocking)
+curl -sf -X POST "https://api.telegram.org/bot${TELEGRAM_BOT_TOKEN}/sendMessage" \
+  -d "chat_id=${TELEGRAM_CHAT_ID}" \
+  -d "parse_mode=Markdown" \
+  -d "text=${MSG}" > /dev/null 2>&1 &

package/dist/guards/test-protect-guard.sh

@@ -3,8 +3,8 @@
 # Hook: PostToolUse (matcher: Edit|Write)
 # Prevents the #1 LLM anti-pattern: modifying tests to match broken code
 
-# $TOOL_INPUT contains the file path and changes
-INPUT="$TOOL_INPUT"
+# $CLAUDE_TOOL_INPUT contains the file path and changes
+INPUT="${CLAUDE_TOOL_INPUT:-$TOOL_INPUT}"
 
 # Check if a test file was modified
 if echo "$INPUT" | grep -qE '\.(test|spec)\.(ts|tsx|js|jsx|py)'; then

package/dist/guards/ui-checklist-guard.sh

@@ -3,7 +3,7 @@
 # Hook: PostToolUse (matcher: Edit|Write)
 # Prevents the "missing states" anti-pattern: LLMs generate happy path only
 
-INPUT="$TOOL_INPUT"
+INPUT="${CLAUDE_TOOL_INPUT:-$TOOL_INPUT}"
 
 # Only check UI component files
 if ! echo "$INPUT" | grep -qE '\.(tsx|jsx|vue|svelte)'; then

package/dist/index.js

@@ -191,7 +191,9 @@ var EXPECTED_GUARDS = [
   "test-protect-guard.sh",
   "session-summary.sh",
   "ui-checklist-guard.sh",
-  "scope-guard.sh"
+  "scope-guard.sh",
+  "error-pattern-guard.sh",
+  "notify-telegram.sh"
 ];
 async function checkGuards(claudeDir) {
   const results = [];
@@ -369,7 +371,7 @@ async function main() {
       break;
     }
     case "init": {
-      const { init } = await import("./init-NXU37FCV.js");
+      const { init } = await import("./init-W3XGDQ6D.js");
       await init();
       break;
     }
@@ -409,23 +411,51 @@ async function main() {
       break;
     }
     case "optimize": {
-      const { optimize } = await import("./optimize-NE47FMOP.js");
-      await optimize();
+      const { optimize } = await import("./optimize-UKMAGQQE.js");
+      const applyFlag = process.argv.includes("--apply");
+      await optimize(applyFlag);
+      break;
+    }
+    case "setup": {
+      const { setup } = await import("./setup-AO3MW46W.js");
+      await setup();
+      break;
+    }
+    case "llm": {
+      const prompt = process.argv.slice(3).join(" ");
+      if (!prompt) {
+        console.error("Usage: rex llm <prompt>");
+        process.exit(1);
+      }
+      const { llm } = await import("./llm-YRORUH7E.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");
+      await context(targetPath);
+      break;
+    }
+    case "gateway": {
+      const { gateway } = await import("./gateway-EOVQXRON.js");
+      await gateway();
       break;
     }
     case "startup": {
-      const { installStartup } = await import("./init-NXU37FCV.js");
+      const { installStartup } = await import("./init-W3XGDQ6D.js");
       installStartup();
       break;
     }
     case "startup-remove": {
-      const { uninstallStartup } = await import("./init-NXU37FCV.js");
+      const { uninstallStartup } = await import("./init-W3XGDQ6D.js");
       uninstallStartup();
       break;
     }
     case "--version":
     case "-v":
-      console.log("rex-claude v2.2.0");
+      console.log("rex-claude v3.0.0");
       break;
     case "help":
     default:
@@ -440,15 +470,24 @@ ${COLORS.bold}Commands:${COLORS.reset}
   rex startup-remove  Remove LaunchAgent
 
 ${COLORS.bold}Memory (requires Ollama):${COLORS.reset}
-  rex ingest      Sync session history to vector DB
-  rex search      Semantic search across past sessions
-  rex optimize    Analyze CLAUDE.md with local LLM
+  rex ingest           Sync session history to vector DB
+  rex search <query>   Semantic search across past sessions
+  rex optimize         Analyze CLAUDE.md with local LLM
+  rex optimize --apply Apply optimizations (with backup)
+
+${COLORS.bold}LLM & Context:${COLORS.reset}
+  rex setup            Install Ollama + models + Telegram gateway
+  rex llm <prompt>     Query local LLM directly
+  rex context [path]   Analyze project, recommend MCP/skills
+
+${COLORS.bold}Telegram Gateway:${COLORS.reset}
+  rex gateway          Start Telegram bot (long-polling, interactive)
 
 ${COLORS.bold}Info:${COLORS.reset}
-  rex help        Show this help
-  rex --version   Show version
+  rex help             Show this help
+  rex --version        Show version
 
-${COLORS.dim}After install: rex init \u2014 everything else is automatic.${COLORS.reset}
+${COLORS.dim}After install: rex init && rex setup \u2014 everything else is automatic.${COLORS.reset}
 `);
   }
 }