rex-claude 4.0.0 → 6.0.0

package/dist/skills-AIWFY5NH.js

@@ -0,0 +1,374 @@
+#!/usr/bin/env node
+import "./chunk-PDX44BCA.js";
+
+// src/skills.ts
+import { homedir } from "os";
+import { existsSync, mkdirSync, readFileSync, writeFileSync, readdirSync, unlinkSync } from "fs";
+import { join } from "path";
+var HOME = homedir();
+var SKILLS_DIR = join(HOME, ".claude", "rex", "skills");
+var COLORS = {
+  reset: "\x1B[0m",
+  bold: "\x1B[1m",
+  dim: "\x1B[2m",
+  green: "\x1B[32m",
+  yellow: "\x1B[33m",
+  red: "\x1B[31m",
+  cyan: "\x1B[36m",
+  magenta: "\x1B[35m"
+};
+var DEFAULT_SKILLS = {
+  "code-review": {
+    description: "Review code for bugs, security issues, and performance problems",
+    requiredTools: ["Read", "Grep", "Glob", "Bash"],
+    requiredMcp: [],
+    body: `# Code Review
+
+## Objective
+
+Review code for bugs, security issues, performance. Report findings with file:line references.
+
+## Process
+
+1. **Understand scope** \u2014 Identify the files and modules under review.
+2. **Read thoroughly** \u2014 Use Read and Grep to examine implementation details.
+3. **Check for bugs** \u2014 Logic errors, off-by-one, null/undefined access, race conditions.
+4. **Check security** \u2014 SQL injection, XSS, secrets in code, missing auth checks (OWASP top 10).
+5. **Check performance** \u2014 Unbounded loops, missing pagination, N+1 queries, large payloads.
+6. **Report** \u2014 List each finding with severity (critical/high/medium/low), file:line, and suggested fix.
+
+## Rules
+
+- Never modify files during a review \u2014 read-only.
+- Always provide file paths and line numbers for every finding.
+- Group findings by severity, most critical first.
+- If no issues found, say so explicitly \u2014 don't invent problems.`
+  },
+  "bug-fix": {
+    description: "Identify root cause, implement fix, verify with tests",
+    requiredTools: ["Read", "Edit", "Write", "Grep", "Glob", "Bash"],
+    requiredMcp: [],
+    body: `# Bug Fix
+
+## Objective
+
+Identify root cause, implement fix, verify with tests. Never delete tests to make them pass.
+
+## Process
+
+1. **Reproduce** \u2014 Understand the bug description. Locate relevant code with Grep/Glob.
+2. **Root cause** \u2014 Trace the issue through the codebase. Read related files to understand context.
+3. **Plan fix** \u2014 Identify the minimal change that fixes the root cause (not symptoms).
+4. **Implement** \u2014 Edit the affected files. Keep changes focused and minimal.
+5. **Verify** \u2014 Run the build. Run tests if they exist. Confirm the fix resolves the issue.
+6. **Side effects** \u2014 Grep for other consumers of changed functions/state. Ensure nothing breaks.
+
+## Rules
+
+- Fix the root cause, not the symptoms.
+- Never delete or skip tests to make them pass \u2014 fix the code instead.
+- If stuck after 2 attempts at the same approach, stop and report what you tried.
+- Always verify the build passes after your fix.`
+  },
+  "refactor": {
+    description: "Improve code quality without changing behavior",
+    requiredTools: ["Read", "Edit", "Write", "Grep", "Glob", "Bash"],
+    requiredMcp: [],
+    body: `# Refactor
+
+## Objective
+
+Improve code quality without changing behavior. Verify builds and tests pass before and after.
+
+## Process
+
+1. **Baseline** \u2014 Run the build and tests BEFORE any changes. Record the results.
+2. **Analyze** \u2014 Read the code to understand current structure, patterns, and pain points.
+3. **Plan** \u2014 Identify specific improvements: extract functions, reduce duplication, improve naming, simplify logic.
+4. **Implement** \u2014 Apply changes incrementally. One logical change at a time.
+5. **Verify** \u2014 Run build and tests AFTER changes. Compare with baseline \u2014 behavior must be identical.
+6. **Review** \u2014 Read back the changed files. Ensure consistency with existing codebase patterns.
+
+## Rules
+
+- Behavior must not change \u2014 refactoring is about structure, not features.
+- Run build before AND after. Both must pass with zero errors.
+- Follow existing codebase conventions (naming, formatting, patterns).
+- Do not over-engineer. Only improve what is clearly problematic.
+- If tests exist, they must all pass after refactoring without modification.`
+  },
+  "deploy-check": {
+    description: "Pre-deploy checklist: build, secrets, env vars, migrations",
+    requiredTools: ["Read", "Grep", "Glob", "Bash"],
+    requiredMcp: [],
+    body: `# Deploy Check
+
+## Objective
+
+Pre-deploy checklist: build passes, no secrets in code, env vars configured, migrations ready.
+
+## Checklist
+
+### 1. Build
+- [ ] \`npm run build\` (or equivalent) passes with zero errors
+- [ ] No TypeScript/linter warnings in changed files
+
+### 2. Secrets & Security
+- [ ] No API keys, tokens, or passwords hardcoded in source
+- [ ] \`.env\` files are in \`.gitignore\`
+- [ ] No \`console.log\` with sensitive data
+- [ ] SQL queries use parameterized statements
+
+### 3. Environment Variables
+- [ ] All required env vars are documented
+- [ ] \`.env.example\` is up to date (if it exists)
+- [ ] No references to localhost/dev URLs in production code
+
+### 4. Database
+- [ ] Migrations are ready and tested
+- [ ] New queries have appropriate indexes
+- [ ] No destructive migrations without rollback plan
+
+### 5. Dependencies
+- [ ] No vulnerable dependencies (\`npm audit\`)
+- [ ] Lock file is committed
+- [ ] No unnecessary new dependencies added
+
+## Rules
+
+- This is a read-only check \u2014 do not modify files.
+- Report each item as PASS / FAIL / N/A with details.
+- Any FAIL is a deploy blocker \u2014 state this clearly.`
+  }
+};
+function ensureDirs() {
+  if (!existsSync(SKILLS_DIR)) mkdirSync(SKILLS_DIR, { recursive: true });
+}
+function installDefaults() {
+  ensureDirs();
+  for (const [name, skill] of Object.entries(DEFAULT_SKILLS)) {
+    const filePath = join(SKILLS_DIR, `${name}.md`);
+    if (existsSync(filePath)) continue;
+    const content = `---
+name: ${name}
+description: ${skill.description}
+requiredTools: [${skill.requiredTools.join(", ")}]
+requiredMcp: [${skill.requiredMcp.join(", ")}]
+---
+
+${skill.body}
+`;
+    writeFileSync(filePath, content);
+  }
+}
+function parseFrontmatter(content) {
+  const fmMatch = content.match(/^---\n([\s\S]*?)\n---\n?([\s\S]*)$/);
+  if (!fmMatch) {
+    return {
+      meta: { name: "unknown", description: "", requiredTools: [], requiredMcp: [] },
+      body: content
+    };
+  }
+  const raw = fmMatch[1];
+  const body = fmMatch[2].trim();
+  const getString = (key) => {
+    const m = raw.match(new RegExp(`^${key}:\\s*(.+)$`, "m"));
+    return m ? m[1].trim() : "";
+  };
+  const getArray = (key) => {
+    const m = raw.match(new RegExp(`^${key}:\\s*\\[([^\\]]*)\\]`, "m"));
+    if (!m) return [];
+    return m[1].split(",").map((s) => s.trim()).filter(Boolean);
+  };
+  return {
+    meta: {
+      name: getString("name"),
+      description: getString("description"),
+      requiredTools: getArray("requiredTools"),
+      requiredMcp: getArray("requiredMcp")
+    },
+    body
+  };
+}
+function readSkill(name) {
+  const filePath = join(SKILLS_DIR, `${name}.md`);
+  if (!existsSync(filePath)) return null;
+  const content = readFileSync(filePath, "utf-8");
+  const { meta, body } = parseFrontmatter(content);
+  return {
+    info: { ...meta, file: `${name}.md`, path: filePath },
+    body
+  };
+}
+function getAllSkills() {
+  ensureDirs();
+  installDefaults();
+  const files = readdirSync(SKILLS_DIR).filter((f) => f.endsWith(".md")).sort();
+  const skills2 = [];
+  for (const file of files) {
+    const filePath = join(SKILLS_DIR, file);
+    try {
+      const content = readFileSync(filePath, "utf-8");
+      const { meta } = parseFrontmatter(content);
+      skills2.push({ ...meta, file, path: filePath });
+    } catch {
+    }
+  }
+  return skills2;
+}
+function loadSkill(name) {
+  ensureDirs();
+  installDefaults();
+  const skill = readSkill(name);
+  if (!skill) return null;
+  return skill.body;
+}
+function listSkills() {
+  return getAllSkills();
+}
+function cmdList(jsonMode) {
+  const skills2 = getAllSkills();
+  if (jsonMode) {
+    console.log(JSON.stringify({ skills: skills2 }, null, 2));
+    return;
+  }
+  if (skills2.length === 0) {
+    console.log("No skills found. They will be created on first use.");
+    return;
+  }
+  const line = "\u2500".repeat(60);
+  console.log(`
+${COLORS.bold}  REX Skills${COLORS.reset}  ${COLORS.dim}(${SKILLS_DIR})${COLORS.reset}
+${line}`);
+  for (const s of skills2) {
+    const tools = s.requiredTools.length > 0 ? s.requiredTools.join(", ") : "none";
+    const mcp = s.requiredMcp.length > 0 ? s.requiredMcp.join(", ") : "none";
+    console.log(`  ${COLORS.cyan}${s.name}${COLORS.reset}`);
+    console.log(`  ${COLORS.dim}${s.description}${COLORS.reset}`);
+    console.log(`  ${COLORS.dim}tools: ${tools}  |  mcp: ${mcp}${COLORS.reset}`);
+    console.log();
+  }
+  console.log(`${line}`);
+  console.log(`${COLORS.dim}  ${skills2.length} skill(s) in ${SKILLS_DIR}${COLORS.reset}
+`);
+}
+function cmdShow(args) {
+  const name = args[0];
+  if (!name) {
+    console.log("Usage: rex skills show <name>");
+    return;
+  }
+  ensureDirs();
+  installDefaults();
+  const skill = readSkill(name);
+  if (!skill) {
+    console.log(`${COLORS.red}Skill not found:${COLORS.reset} ${name}`);
+    console.log(`${COLORS.dim}Available: ${getAllSkills().map((s2) => s2.name).join(", ")}${COLORS.reset}`);
+    return;
+  }
+  const s = skill.info;
+  const line = "\u2500".repeat(60);
+  console.log(`
+${COLORS.bold}  ${s.name}${COLORS.reset}
+${line}`);
+  console.log(`  ${COLORS.dim}Description:${COLORS.reset} ${s.description}`);
+  console.log(`  ${COLORS.dim}Tools:${COLORS.reset}       ${s.requiredTools.join(", ") || "none"}`);
+  console.log(`  ${COLORS.dim}MCP:${COLORS.reset}         ${s.requiredMcp.join(", ") || "none"}`);
+  console.log(`  ${COLORS.dim}Path:${COLORS.reset}        ${s.path}`);
+  console.log(`${line}
+`);
+  console.log(skill.body);
+  console.log();
+}
+function cmdAdd(args) {
+  const name = args[0];
+  if (!name) {
+    console.log("Usage: rex skills add <name>");
+    console.log("Creates a new skill template in the skills directory.");
+    return;
+  }
+  ensureDirs();
+  const slug = name.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
+  const filePath = join(SKILLS_DIR, `${slug}.md`);
+  if (existsSync(filePath)) {
+    console.log(`${COLORS.yellow}Skill already exists:${COLORS.reset} ${slug}`);
+    console.log(`${COLORS.dim}Edit it at: ${filePath}${COLORS.reset}`);
+    return;
+  }
+  const content = `---
+name: ${slug}
+description: TODO \u2014 describe this skill
+requiredTools: [Read, Grep]
+requiredMcp: []
+---
+
+# ${slug.split("-").map((w) => w.charAt(0).toUpperCase() + w.slice(1)).join(" ")}
+
+## Objective
+
+TODO \u2014 what this skill does.
+
+## Process
+
+1. TODO \u2014 step 1
+2. TODO \u2014 step 2
+3. TODO \u2014 step 3
+
+## Rules
+
+- TODO \u2014 constraints and guardrails
+`;
+  writeFileSync(filePath, content);
+  console.log(`${COLORS.green}Skill created:${COLORS.reset} ${slug}`);
+  console.log(`${COLORS.dim}Edit it at: ${filePath}${COLORS.reset}`);
+}
+function cmdDelete(args) {
+  const name = args[0];
+  if (!name) {
+    console.log("Usage: rex skills delete <name>");
+    return;
+  }
+  ensureDirs();
+  const filePath = join(SKILLS_DIR, `${name}.md`);
+  if (!existsSync(filePath)) {
+    console.log(`${COLORS.red}Skill not found:${COLORS.reset} ${name}`);
+    return;
+  }
+  unlinkSync(filePath);
+  console.log(`${COLORS.green}Deleted:${COLORS.reset} ${name}`);
+}
+async function skills(args) {
+  ensureDirs();
+  installDefaults();
+  const sub = args[0] || "list";
+  const rest = args.slice(1);
+  const jsonMode = args.includes("--json");
+  switch (sub) {
+    case "list":
+      cmdList(jsonMode);
+      return;
+    case "show":
+      cmdShow(rest);
+      return;
+    case "add":
+      cmdAdd(rest);
+      return;
+    case "delete":
+      cmdDelete(rest);
+      return;
+    default:
+      console.log("Usage: rex skills <list|show|add|delete>");
+      console.log("");
+      console.log("  rex skills list              List all available skills");
+      console.log("  rex skills show <name>       Show skill content");
+      console.log("  rex skills add <name>        Create a new skill template");
+      console.log("  rex skills delete <name>     Delete a skill");
+      console.log("");
+      console.log(`Skills directory: ${SKILLS_DIR}`);
+  }
+}
+export {
+  listSkills,
+  loadSkill,
+  skills
+};

package/dist/voice-RITC3EVC.js

@@ -0,0 +1,248 @@
+#!/usr/bin/env node
+import "./chunk-PDX44BCA.js";
+
+// src/voice.ts
+import { homedir } from "os";
+import { existsSync, mkdirSync, readFileSync, readdirSync, statSync, writeFileSync } from "fs";
+import { join } from "path";
+import { spawnSync } from "child_process";
+var HOME = homedir();
+var RUNTIME_DIR = join(HOME, ".rex-memory", "runtime");
+var RECORDINGS_DIR = join(HOME, ".rex-memory", "recordings");
+var SETTINGS_FILE = join(RUNTIME_DIR, "voice-settings.json");
+function ensureDirs() {
+  if (!existsSync(RUNTIME_DIR)) mkdirSync(RUNTIME_DIR, { recursive: true });
+}
+function readSettings() {
+  try {
+    if (existsSync(SETTINGS_FILE)) {
+      const parsed = JSON.parse(readFileSync(SETTINGS_FILE, "utf-8"));
+      return {
+        optimizeEnabled: parsed.optimizeEnabled === true,
+        optimizeModel: typeof parsed.optimizeModel === "string" && parsed.optimizeModel.trim().length > 0 ? parsed.optimizeModel : process.env.REX_OPTIMIZE_MODEL || "qwen3.5:4b"
+      };
+    }
+  } catch {
+  }
+  return {
+    optimizeEnabled: false,
+    optimizeModel: process.env.REX_OPTIMIZE_MODEL || "qwen3.5:4b"
+  };
+}
+function writeSettings(settings) {
+  ensureDirs();
+  writeFileSync(SETTINGS_FILE, JSON.stringify(settings, null, 2));
+}
+function whisperExists() {
+  const check = spawnSync("whisper-cli", ["--help"], { stdio: "ignore" });
+  return check.status === 0;
+}
+function defaultWhisperModelPath() {
+  const envPath = process.env.REX_WHISPER_MODEL;
+  if (envPath) return envPath;
+  const candidates = [
+    join(HOME, ".rex-memory", "models", "ggml-base.en.bin"),
+    join(HOME, ".rex-memory", "models", "ggml-small.en.bin"),
+    join(HOME, ".rex-memory", "models", "ggml-tiny.en.bin"),
+    join(HOME, ".whisper", "models", "ggml-base.en.bin"),
+    join(HOME, ".whisper", "models", "ggml-small.en.bin"),
+    join(HOME, ".whisper", "models", "ggml-tiny.en.bin")
+  ];
+  const found = candidates.find((c) => existsSync(c));
+  return found || candidates[0];
+}
+function latestRecording() {
+  if (!existsSync(RECORDINGS_DIR)) return null;
+  const files = readdirSync(RECORDINGS_DIR).filter((f) => f.endsWith(".wav")).map((f) => join(RECORDINGS_DIR, f));
+  if (files.length === 0) return null;
+  files.sort((a, b) => {
+    try {
+      return statSync(b).mtimeMs - statSync(a).mtimeMs;
+    } catch {
+      return 0;
+    }
+  });
+  return files[0] || null;
+}
+function parseWhisperOutput(raw) {
+  const lines = raw.split("\n").map((l) => l.trim()).filter(Boolean);
+  const cleaned = [];
+  for (const line of lines) {
+    if (line.startsWith("whisper_") || line.startsWith("main:") || line.startsWith("system_info:")) {
+      continue;
+    }
+    const ts = line.match(/^\[[0-9:.\-\s>]+\]\s*(.*)$/);
+    if (ts) {
+      if (ts[1] && ts[1].trim().length > 0) cleaned.push(ts[1].trim());
+      continue;
+    }
+    cleaned.push(line);
+  }
+  const text = cleaned.join(" ").replace(/\s+/g, " ").trim();
+  return text;
+}
+async function optimizePrompt(text, model) {
+  const ollama = process.env.OLLAMA_URL || "http://localhost:11434";
+  const prompt = `You are a transcription optimizer for coding assistants. Rewrite the transcript into a clean, structured prompt with technical terms corrected and no filler. Return only optimized text.
+
+Transcript:
+${text}`;
+  const res = await fetch(`${ollama}/api/generate`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({
+      model,
+      stream: false,
+      prompt
+    })
+  });
+  if (!res.ok) {
+    throw new Error(`LLM optimize failed (${res.status})`);
+  }
+  const data = await res.json();
+  const out = (data.response || "").trim();
+  if (!out) throw new Error("LLM optimize returned empty output");
+  return out;
+}
+async function transcribe(args) {
+  const jsonMode = args.includes("--json");
+  const optimizeFlag = args.includes("--optimize");
+  const fileArg = args.find((a) => a.endsWith(".wav")) || null;
+  const source = fileArg || latestRecording();
+  if (!source) {
+    const msg = "No recording found. Provide a WAV path or start audio logger first.";
+    if (jsonMode) {
+      console.log(JSON.stringify({ ok: false, error: msg }, null, 2));
+      return;
+    }
+    console.error(msg);
+    process.exit(1);
+  }
+  if (!whisperExists()) {
+    const msg = "whisper-cli not found. Install whisper.cpp CLI and ensure whisper-cli is in PATH.";
+    if (jsonMode) {
+      console.log(JSON.stringify({ ok: false, error: msg }, null, 2));
+      return;
+    }
+    console.error(msg);
+    process.exit(1);
+  }
+  const modelPath = defaultWhisperModelPath();
+  if (!existsSync(modelPath)) {
+    const msg = `Whisper model not found: ${modelPath}. Set REX_WHISPER_MODEL or place ggml model in ~/.rex-memory/models.`;
+    if (jsonMode) {
+      console.log(JSON.stringify({ ok: false, error: msg }, null, 2));
+      return;
+    }
+    console.error(msg);
+    process.exit(1);
+  }
+  const run = spawnSync("whisper-cli", ["-m", modelPath, "-f", source, "-nt"], {
+    encoding: "utf-8",
+    maxBuffer: 1024 * 1024 * 10
+  });
+  if (run.status !== 0) {
+    const err = (run.stderr || run.stdout || "").trim() || "whisper-cli failed";
+    if (jsonMode) {
+      console.log(JSON.stringify({ ok: false, error: err }, null, 2));
+      return;
+    }
+    console.error(err);
+    process.exit(1);
+  }
+  const transcript = parseWhisperOutput((run.stdout || "").toString());
+  const settings = readSettings();
+  const optimize = optimizeFlag || settings.optimizeEnabled;
+  let optimized = null;
+  let optimizeError = null;
+  if (optimize && transcript.length > 0) {
+    try {
+      optimized = await optimizePrompt(transcript, settings.optimizeModel);
+    } catch (e) {
+      optimizeError = e instanceof Error ? e.message : String(e);
+    }
+  }
+  if (jsonMode) {
+    console.log(
+      JSON.stringify(
+        {
+          ok: true,
+          source,
+          modelPath,
+          transcript,
+          optimizeEnabled: optimize,
+          optimizeModel: settings.optimizeModel,
+          optimized,
+          optimizeError,
+          output: optimized || transcript
+        },
+        null,
+        2
+      )
+    );
+    return;
+  }
+  if (optimized) {
+    console.log(optimized);
+  } else {
+    console.log(transcript);
+    if (optimizeError) {
+      console.error(`Optimize skipped: ${optimizeError}`);
+    }
+  }
+}
+function showStatus(jsonMode) {
+  const settings = readSettings();
+  const payload = {
+    optimizeEnabled: settings.optimizeEnabled,
+    optimizeModel: settings.optimizeModel,
+    whisperCliAvailable: whisperExists(),
+    whisperModelPath: defaultWhisperModelPath(),
+    whisperModelExists: existsSync(defaultWhisperModelPath()),
+    recordingsDir: RECORDINGS_DIR
+  };
+  if (jsonMode) {
+    console.log(JSON.stringify(payload, null, 2));
+    return;
+  }
+  console.log(`Optimize: ${payload.optimizeEnabled ? "on" : "off"} (${payload.optimizeModel})`);
+  console.log(`whisper-cli: ${payload.whisperCliAvailable ? "available" : "missing"}`);
+  console.log(`Model: ${payload.whisperModelPath}`);
+  console.log(`Recordings: ${payload.recordingsDir}`);
+}
+function setOptimize(args) {
+  const value = (args[0] || "").toLowerCase();
+  const model = args[1];
+  if (!["on", "off"].includes(value)) {
+    console.log("Usage: rex voice set-optimize <on|off> [model]");
+    process.exit(1);
+  }
+  const current = readSettings();
+  const next = {
+    optimizeEnabled: value === "on",
+    optimizeModel: model || current.optimizeModel
+  };
+  writeSettings(next);
+  console.log(JSON.stringify({ ok: true, ...next }, null, 2));
+}
+async function voice(args) {
+  const sub = args[0] || "status";
+  const rest = args.slice(1);
+  switch (sub) {
+    case "status":
+    case "settings":
+      showStatus(args.includes("--json"));
+      return;
+    case "set-optimize":
+      setOptimize(rest);
+      return;
+    case "transcribe":
+      await transcribe(rest);
+      return;
+    default:
+      console.log("Usage: rex voice <status|settings|set-optimize|transcribe>");
+  }
+}
+export {
+  voice
+};

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "rex-claude",
-  "version": "4.0.0",
-  "description": "Claude Code sous steroides — guards, health checks, memory RAG",
+  "version": "6.0.0",
+  "description": "REX — dev assistant with Telegram gateway, memory RAG, guards, model switching, and macOS native app",
   "type": "module",
   "bin": {
     "rex": "./dist/index.js"
@@ -22,7 +22,12 @@
     "productivity",
     "ai-assistant",
     "guards",
-    "hooks"
+    "hooks",
+    "telegram",
+    "memory",
+    "rag",
+    "ollama",
+    "qwen"
   ],
   "author": "Kevin <kevin@dstudio.company>",
   "license": "MIT",
@@ -34,6 +39,10 @@
   "engines": {
     "node": ">=20"
   },
+  "dependencies": {
+    "better-sqlite3": "^11.8.1",
+    "sqlite-vec": "^0.1.6"
+  },
   "devDependencies": {
     "@rex/core": "workspace:*",
     "@types/node": "^25.3.3",