rex-claude 1.0.0

package/memory/src/ingest.ts

@@ -0,0 +1,257 @@
+import Database from "better-sqlite3";
+import * as sqliteVec from "sqlite-vec";
+import { readFileSync, readdirSync, existsSync, statSync } from "fs";
+import { join, basename } from "path";
+import { embed, embeddingToBuffer, EMBEDDING_DIM } from "./embed.js";
+
+const DB_PATH = join(import.meta.dirname, "..", "db", "rex.sqlite");
+const MAX_CHUNKS_PER_FILE = 50;
+const CHUNK_SIZE = 1000;
+const MAX_CHUNK_LENGTH = 2000;
+const MIN_TEXT_LENGTH = 50;
+const MIN_FINAL_CHUNK = 100;
+const EMBED_RETRY_DELAY = 2000;
+const EMBED_MAX_RETRIES = 3;
+
+let _db: Database.Database | null = null;
+
+export function getDb(): Database.Database {
+  if (_db) return _db;
+
+  const dbDir = join(import.meta.dirname, "..", "db");
+  if (!existsSync(dbDir)) {
+    const { mkdirSync } = require("fs");
+    mkdirSync(dbDir, { recursive: true });
+  }
+
+  _db = new Database(DB_PATH);
+  sqliteVec.load(_db);
+
+  _db.pragma("journal_mode = WAL");
+  _db.defaultSafeIntegers(false);
+
+  _db.exec(`
+    CREATE TABLE IF NOT EXISTS memories (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      content TEXT NOT NULL,
+      category TEXT NOT NULL DEFAULT 'general',
+      source TEXT,
+      project TEXT,
+      created_at TEXT DEFAULT (datetime('now'))
+    );
+
+    CREATE VIRTUAL TABLE IF NOT EXISTS memory_vec USING vec0(
+      embedding float[${EMBEDDING_DIM}]
+    );
+
+    CREATE TABLE IF NOT EXISTS ingest_log (
+      file_path TEXT PRIMARY KEY,
+      chunks_count INTEGER,
+      ingested_at TEXT DEFAULT (datetime('now'))
+    );
+  `);
+
+  return _db;
+}
+
+async function embedWithRetry(text: string): Promise<Float32Array> {
+  for (let attempt = 1; attempt <= EMBED_MAX_RETRIES; attempt++) {
+    try {
+      return await embed(text);
+    } catch (err) {
+      if (attempt === EMBED_MAX_RETRIES) throw err;
+      console.error(`  Embed attempt ${attempt} failed, retrying in ${EMBED_RETRY_DELAY}ms...`);
+      await new Promise((r) => setTimeout(r, EMBED_RETRY_DELAY));
+    }
+  }
+  throw new Error("Unreachable");
+}
+
+export async function learn(fact: string, category: string = "general", source?: string, project?: string): Promise<void> {
+  const db = getDb();
+
+  let embedding: Float32Array;
+  try {
+    embedding = await embedWithRetry(fact);
+  } catch (err) {
+    console.error(`  Skipping chunk (embedding failed): ${(err as Error).message}`);
+    return;
+  }
+
+  try {
+    const info = db.prepare("INSERT INTO memories (content, category, source, project) VALUES (?, ?, ?, ?)").run(fact, category, source ?? null, project ?? null);
+    db.prepare("INSERT INTO memory_vec (rowid, embedding) VALUES (CAST(? AS INTEGER), ?)").run(Number(info.lastInsertRowid), embeddingToBuffer(embedding));
+  } catch (err) {
+    console.error(`  Skipping chunk (DB insert failed): ${(err as Error).message}`);
+  }
+}
+
+export async function getContext(projectPath: string): Promise<string> {
+  const db = getDb();
+  const projectName = basename(projectPath);
+
+  const projectMemories = db
+    .prepare("SELECT content, category FROM memories WHERE project = ? ORDER BY created_at DESC LIMIT 20")
+    .all(projectName) as Array<{ content: string; category: string }>;
+
+  let semanticResults: Array<{ content: string; category: string; score: number }> = [];
+  try {
+    semanticResults = await (await import("./search.js")).search(projectName, 5);
+  } catch {
+    // Ollama might be down — degrade gracefully
+  }
+
+  const sections: string[] = [];
+
+  if (projectMemories.length) {
+    sections.push("## Project memories\n" + projectMemories.map((m) => `- [${m.category}] ${m.content}`).join("\n"));
+  }
+
+  if (semanticResults.length) {
+    sections.push("## Related context\n" + semanticResults.map((r) => `- [${r.category}] (${r.score.toFixed(2)}) ${r.content}`).join("\n"));
+  }
+
+  return sections.join("\n\n") || "";
+}
+
+function extractTextFromMessage(msg: any): string {
+  if (!msg?.message?.content) return "";
+  if (typeof msg.message.content === "string") return msg.message.content;
+  if (!Array.isArray(msg.message.content)) return "";
+  return msg.message.content
+    .filter((c: any) => c?.type === "text" && typeof c?.text === "string")
+    .map((c: any) => c.text)
+    .join("\n");
+}
+
+function chunkText(lines: string[]): string[] {
+  const chunks: string[] = [];
+  let current = "";
+
+  for (const line of lines) {
+    try {
+      const msg = JSON.parse(line);
+      if (msg.type !== "human" && msg.type !== "assistant") continue;
+
+      const text = extractTextFromMessage(msg);
+      if (text.length < MIN_TEXT_LENGTH) continue;
+
+      current += text + "\n";
+      if (current.length > CHUNK_SIZE) {
+        chunks.push(current.slice(0, MAX_CHUNK_LENGTH));
+        current = "";
+      }
+    } catch {
+      // skip malformed JSON lines
+    }
+  }
+
+  if (current.length > MIN_FINAL_CHUNK) {
+    chunks.push(current.slice(0, MAX_CHUNK_LENGTH));
+  }
+
+  return chunks.slice(0, MAX_CHUNKS_PER_FILE);
+}
+
+async function checkOllama(): Promise<boolean> {
+  try {
+    const res = await fetch(`${process.env.OLLAMA_URL || "http://localhost:11434"}/api/tags`);
+    return res.ok;
+  } catch {
+    return false;
+  }
+}
+
+async function ingestSessions() {
+  // Pre-flight: check Ollama
+  if (!(await checkOllama())) {
+    console.error("ERROR: Ollama is not running. Start it with: ollama serve");
+    process.exit(1);
+  }
+
+  const sessionsDir = join(process.env.HOME || "~", ".claude", "projects");
+  if (!existsSync(sessionsDir)) {
+    console.error("No sessions directory found at", sessionsDir);
+    return;
+  }
+
+  const db = getDb();
+
+  // Use ingest_log to track already-processed files (more reliable than source column)
+  const alreadyIngested = new Set(
+    (db.prepare("SELECT file_path FROM ingest_log").all() as Array<{ file_path: string }>).map((r) => r.file_path)
+  );
+
+  let totalIngested = 0;
+  let totalSkipped = 0;
+  let totalErrors = 0;
+
+  let projectDirs: string[];
+  try {
+    projectDirs = readdirSync(sessionsDir).filter((d) => {
+      try {
+        return statSync(join(sessionsDir, d)).isDirectory();
+      } catch {
+        return false;
+      }
+    });
+  } catch (err) {
+    console.error("Cannot read sessions directory:", err);
+    return;
+  }
+
+  for (const projectDir of projectDirs) {
+    const projectPath = join(sessionsDir, projectDir);
+
+    let files: string[];
+    try {
+      files = readdirSync(projectPath).filter((f) => f.endsWith(".jsonl"));
+    } catch {
+      continue;
+    }
+
+    for (const file of files) {
+      const filePath = join(projectPath, file);
+
+      if (alreadyIngested.has(filePath)) {
+        totalSkipped++;
+        continue;
+      }
+
+      try {
+        const content = readFileSync(filePath, "utf-8");
+        const lines = content.split("\n").filter(Boolean);
+        const chunks = chunkText(lines);
+
+        if (chunks.length === 0) {
+          // Mark as processed even if empty (no need to re-parse)
+          db.prepare("INSERT OR IGNORE INTO ingest_log (file_path, chunks_count) VALUES (?, 0)").run(filePath);
+          continue;
+        }
+
+        let fileIngested = 0;
+        for (const chunk of chunks) {
+          await learn(chunk, "session", filePath, projectDir);
+          fileIngested++;
+        }
+
+        db.prepare("INSERT OR IGNORE INTO ingest_log (file_path, chunks_count) VALUES (?, ?)").run(filePath, fileIngested);
+        totalIngested += fileIngested;
+
+        if (fileIngested > 0) {
+          console.log(`  ${file}: ${fileIngested} chunks`);
+        }
+      } catch (err) {
+        totalErrors++;
+        console.error(`  Error ${file}: ${(err as Error).message}`);
+      }
+    }
+  }
+
+  console.log(`\nDone: ${totalIngested} ingested, ${totalSkipped} skipped (already done), ${totalErrors} errors`);
+}
+
+// Run CLI if called directly
+if (process.argv[1]?.endsWith("ingest.ts") || process.argv[1]?.endsWith("ingest.js")) {
+  ingestSessions().catch(console.error);
+}

package/memory/src/search.ts

@@ -0,0 +1,32 @@
+import { getDb } from "./ingest.js";
+import { embed, embeddingToBuffer } from "./embed.js";
+
+export interface SearchResult {
+  content: string;
+  category: string;
+  score: number;
+  created_at: string;
+}
+
+export async function search(query: string, limit: number = 10): Promise<SearchResult[]> {
+  const db = getDb();
+  const queryEmbedding = await embed(query);
+  const buf = embeddingToBuffer(queryEmbedding);
+
+  const rows = db
+    .prepare(
+      `SELECT m.content, m.category, m.created_at, vec_distance_cosine(e.embedding, ?) as distance
+       FROM memory_vec e
+       JOIN memories m ON m.id = e.rowid
+       ORDER BY distance ASC
+       LIMIT CAST(? AS INTEGER)`
+    )
+    .all(buf, limit) as Array<{ content: string; category: string; created_at: string; distance: number }>;
+
+  return rows.map((r) => ({
+    content: r.content,
+    category: r.category,
+    score: 1 - r.distance,
+    created_at: r.created_at,
+  }));
+}

package/memory/src/server.ts

@@ -0,0 +1,69 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { z } from "zod";
+import { search } from "./search.js";
+import { learn, getContext } from "./ingest.js";
+
+const server = new McpServer({
+  name: "rex-memory",
+  version: "1.0.0",
+});
+
+server.tool(
+  "rex_search",
+  "Search past sessions and learned facts semantically",
+  { query: z.string().describe("Natural language search query"), limit: z.number().optional().default(10) },
+  async ({ query, limit }) => {
+    const results = await search(query, limit);
+    return {
+      content: [
+        {
+          type: "text" as const,
+          text: results.length
+            ? results.map((r) => `[${r.category}] (score: ${r.score.toFixed(3)})\n${r.content}`).join("\n---\n")
+            : "No relevant memories found.",
+        },
+      ],
+    };
+  }
+);
+
+server.tool(
+  "rex_learn",
+  "Memorize a fact, pattern, or lesson learned",
+  {
+    fact: z.string().describe("The fact or pattern to remember"),
+    category: z.string().optional().default("general").describe("Category: pattern, debug, preference, architecture, lesson"),
+  },
+  async ({ fact, category }) => {
+    await learn(fact, category);
+    return {
+      content: [{ type: "text" as const, text: `Learned: [${category}] ${fact.slice(0, 80)}...` }],
+    };
+  }
+);
+
+server.tool(
+  "rex_context",
+  "Get relevant context for the current project",
+  {
+    project_path: z.string().describe("Absolute path to the project directory"),
+  },
+  async ({ project_path }) => {
+    const context = await getContext(project_path);
+    return {
+      content: [{ type: "text" as const, text: context || "No context found for this project." }],
+    };
+  }
+);
+
+async function main() {
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+  console.error("REX Memory MCP server running on stdio");
+}
+
+main().catch((err) => {
+  console.error("Fatal:", err);
+  process.exit(1);
+});

package/memory/tsconfig.json

@@ -0,0 +1,14 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "Node16",
+    "moduleResolution": "Node16",
+    "outDir": "dist",
+    "rootDir": "src",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "declaration": true
+  },
+  "include": ["src"]
+}

package/package.json

@@ -0,0 +1,39 @@
+{
+  "name": "rex-claude",
+  "version": "1.0.0",
+  "description": "REX — Config unifiée + MCP memory server + activity logger pour Claude Code",
+  "type": "module",
+  "bin": {
+    "rex": "./dist/cli.js"
+  },
+  "files": [
+    "dist/",
+    "dotfiles/",
+    "memory/src/",
+    "memory/package.json",
+    "memory/package-lock.json",
+    "memory/tsconfig.json",
+    "activity/",
+    "tmux/"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "prepublishOnly": "npm run build"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "keywords": [
+    "claude-code",
+    "claude",
+    "mcp",
+    "dev-tools",
+    "dotfiles"
+  ],
+  "author": "Kevin <kevin@dstudio.company>",
+  "license": "MIT",
+  "devDependencies": {
+    "@types/node": "^25.3.3",
+    "typescript": "^5.7.0"
+  }
+}

package/tmux/.tmux.conf

@@ -0,0 +1,73 @@
+# REX tmux config — optimized for Claude Code agent teams
+
+# Modern terminal + colors
+set -g default-terminal "tmux-256color"
+set -ga terminal-overrides ",xterm-256color:Tc"
+
+# Shell
+set -g default-shell /bin/zsh
+
+# Longer scrollback for agent output
+set -g history-limit 50000
+
+# Faster escape (important for Claude Code responsiveness)
+set -sg escape-time 10
+
+# Mouse support
+set -g mouse on
+
+# Start windows/panes at 1
+set -g base-index 1
+setw -g pane-base-index 1
+
+# Renumber windows on close
+set -g renumber-windows on
+
+# Activity monitoring (useful for agent teams)
+setw -g monitor-activity on
+set -g visual-activity off
+
+# Status bar
+set -g status-position bottom
+set -g status-interval 5
+set -g status-style "bg=colour235,fg=colour248"
+set -g status-left "#[bg=colour31,fg=colour255,bold] #S #[default] "
+set -g status-left-length 30
+set -g status-right "#[fg=colour245]%H:%M #[fg=colour31]#h"
+set -g status-right-length 50
+
+# Window status
+setw -g window-status-format " #I:#W "
+setw -g window-status-current-format "#[bg=colour31,fg=colour255,bold] #I:#W "
+
+# Pane borders
+set -g pane-border-style "fg=colour238"
+set -g pane-active-border-style "fg=colour31"
+
+# Allow long-running processes (agent teams)
+set -g remain-on-exit off
+
+# Increase message display time
+set -g display-time 2000
+set -g display-panes-time 2000
+
+# Focus events (needed for some editors/tools)
+set -g focus-events on
+
+# Prefix: Ctrl-a (easier than Ctrl-b)
+unbind C-b
+set -g prefix C-a
+bind C-a send-prefix
+
+# Split panes with | and -
+bind | split-window -h -c "#{pane_current_path}"
+bind - split-window -v -c "#{pane_current_path}"
+
+# Navigate panes with Alt+arrow
+bind -n M-Left select-pane -L
+bind -n M-Right select-pane -R
+bind -n M-Up select-pane -U
+bind -n M-Down select-pane -D
+
+# Reload config
+bind r source-file ~/.tmux.conf \; display "Config reloaded"