claude-smart 0.2.41 → 0.2.43

package/plugin/vendor/reflexio/reflexio/integrations/openclaw/plugin/lib/server.ts

@@ -0,0 +1,103 @@
+// Server management: URL resolution, health check, auto-start.
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+import { spawn } from "node:child_process";
+
+export type CommandRunner = (
+  argv: string[],
+  opts: { timeoutMs: number; input?: string },
+) => Promise<{ stdout: string; stderr: string; code: number | null }>;
+
+type Logger = {
+  info?: (msg: string) => void;
+  warn?: (msg: string) => void;
+  error?: (msg: string) => void;
+};
+
+const LOGS_DIR = path.join(os.homedir(), ".reflexio", "logs");
+const STARTING_FLAG = path.join(LOGS_DIR, ".server-starting");
+const DEFAULT_URL = "http://127.0.0.1:8081";
+const DEFAULT_STALE_FLAG_MS = 2 * 60 * 1000;
+
+/** Resolve Reflexio server URL: env var > ~/.reflexio/.env > default. */
+export function resolveServerUrl(): string {
+  if (process.env.REFLEXIO_URL) return process.env.REFLEXIO_URL;
+  try {
+    const envPath = path.join(os.homedir(), ".reflexio", ".env");
+    const content = fs.readFileSync(envPath, "utf-8");
+    const match = content.match(/^REFLEXIO_URL="?([^"\n]+)/m);
+    if (match) return match[1];
+  } catch {
+    // .env file missing
+  }
+  return DEFAULT_URL;
+}
+
+/** Check if a URL points to a local server. */
+export function isLocalServer(url: string): boolean {
+  try {
+    const parsed = new URL(url);
+    return parsed.hostname === "127.0.0.1" || parsed.hostname === "localhost";
+  } catch {
+    return url.includes("127.0.0.1") || url.includes("localhost");
+  }
+}
+
+/**
+ * Ensure the local Reflexio server is running.
+ * Remote servers are never auto-started. Uses a flag file to prevent concurrent starts.
+ */
+export async function ensureServerRunning(
+  runner: CommandRunner,
+  opts: { staleFlagMs?: number; log?: Logger } = {},
+): Promise<void> {
+  const serverUrl = resolveServerUrl();
+  if (!isLocalServer(serverUrl)) return;
+
+  const staleFlagMs = opts.staleFlagMs ?? DEFAULT_STALE_FLAG_MS;
+
+  // Check flag file — if recent, another start is in progress
+  try {
+    const stat = fs.statSync(STARTING_FLAG);
+    if (Date.now() - stat.mtimeMs < staleFlagMs) {
+      opts.log?.info?.("[reflexio] Server start already in progress, skipping");
+      return;
+    }
+    fs.unlinkSync(STARTING_FLAG);
+  } catch {
+    // Flag doesn't exist — proceed
+  }
+
+  // Health check
+  try {
+    const result = await runner(
+      ["curl", "-sf", "--max-time", "2", `${serverUrl}/health`],
+      { timeoutMs: 3_000 },
+    );
+    if (result.code === 0) return; // Server healthy
+  } catch {
+    // Server not running
+  }
+
+  // Start server in background
+  fs.mkdirSync(LOGS_DIR, { recursive: true, mode: 0o700 });
+  fs.writeFileSync(STARTING_FLAG, String(Date.now()), { mode: 0o600 });
+
+  const logPath = path.join(LOGS_DIR, "server.log");
+  const logFd = fs.openSync(logPath, "a");
+  const child = spawn(
+    "reflexio",
+    ["services", "start", "--only", "backend"],
+    { detached: true, stdio: ["ignore", logFd, logFd] },
+  );
+  child.unref();
+  fs.closeSync(logFd);
+
+  // Remove stale flag after 30 seconds
+  setTimeout(() => {
+    try { fs.unlinkSync(STARTING_FLAG); } catch { /* already removed */ }
+  }, 30_000).unref();
+
+  opts.log?.info?.("[reflexio] Server not running — starting in background");
+}

package/plugin/vendor/reflexio/reflexio/integrations/openclaw/plugin/lib/sqlite-buffer.ts

@@ -0,0 +1,156 @@
+// SQLite session buffer — persistent, crash-safe conversation store.
+import Database from "better-sqlite3";
+import * as fs from "node:fs";
+import * as path from "node:path";
+
+const MAX_CONTENT_LENGTH = 10_000;
+
+export interface Turn {
+  id: number;
+  session_id: string;
+  role: string;
+  content: string;
+  timestamp: string;
+  published: number;
+  retry_count: number;
+}
+
+/** Smart truncation: preserve head + tail with marker, guaranteed <= maxLength. */
+export function smartTruncate(
+  content: string,
+  maxLength: number = MAX_CONTENT_LENGTH,
+): string {
+  if (!content || content.length <= maxLength) return content || "";
+  // Use a fixed-width marker estimate to break the circular dependency
+  // between marker length and truncated count.
+  const markerTemplate = "\n\n[...truncated NNNNNNN chars...]\n\n"; // ~38 chars
+  const budget = maxLength - markerTemplate.length;
+  if (budget <= 0) return content.slice(0, maxLength);
+  const headLen = Math.floor(budget * 0.8);
+  const tailLen = budget - headLen;
+  const truncated = content.length - headLen - tailLen;
+  const marker = `\n\n[...truncated ${truncated} chars...]\n\n`;
+  const result =
+    tailLen <= 0
+      ? content.slice(0, headLen) + marker
+      : content.slice(0, headLen) + marker + content.slice(-tailLen);
+  // Final safety clamp for edge cases (very large truncated counts exceeding reserved marker width)
+  return result.length <= maxLength ? result : result.slice(0, maxLength);
+}
+
+/** Open (or create) the SQLite database and ensure schema exists. */
+export function openDb(dbPath: string): Database.Database {
+  fs.mkdirSync(path.dirname(dbPath), { recursive: true, mode: 0o700 });
+  const db = new Database(dbPath);
+  db.pragma("journal_mode = WAL");
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS turns (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      session_id TEXT NOT NULL,
+      role TEXT NOT NULL,
+      content TEXT NOT NULL,
+      timestamp TEXT NOT NULL,
+      published INTEGER DEFAULT 0,
+      retry_count INTEGER DEFAULT 0
+    );
+    CREATE INDEX IF NOT EXISTS idx_session_published
+      ON turns(session_id, published);
+  `);
+  try {
+    db.exec("ALTER TABLE turns ADD COLUMN retry_count INTEGER DEFAULT 0");
+  } catch {
+    // Column already exists
+  }
+  return db;
+}
+
+/** Insert a single turn into the buffer. */
+export function insertTurn(
+  db: Database.Database,
+  sessionId: string,
+  role: string,
+  content: string,
+  maxContentLength: number = MAX_CONTENT_LENGTH,
+): void {
+  const truncated = smartTruncate(content, maxContentLength);
+  const now = new Date().toISOString();
+  db.prepare(
+    "INSERT INTO turns (session_id, role, content, timestamp) VALUES (?, ?, ?, ?)",
+  ).run(sessionId, role, truncated, now);
+}
+
+/** Get unpublished turns for a session, respecting retry limit. */
+export function getUnpublished(
+  db: Database.Database,
+  sessionId: string,
+  maxRetries: number,
+  maxInteractions: number,
+): Turn[] {
+  return db
+    .prepare(
+      "SELECT * FROM turns WHERE session_id = ? AND published = 0 AND retry_count < ? ORDER BY id LIMIT ?",
+    )
+    .all(sessionId, maxRetries, maxInteractions) as Turn[];
+}
+
+/** Get distinct session IDs with unpublished turns (excluding current session). */
+export function getOldUnpublishedSessions(
+  db: Database.Database,
+  currentSessionId: string,
+  maxRetries: number,
+  limit: number,
+): string[] {
+  const rows = db
+    .prepare(
+      "SELECT session_id FROM turns WHERE published = 0 AND retry_count < ? AND session_id != ? GROUP BY session_id ORDER BY MIN(id) LIMIT ?",
+    )
+    .all(maxRetries, currentSessionId, limit) as { session_id: string }[];
+  return rows.map((r) => r.session_id);
+}
+
+/** Count unpublished turns for a session. */
+export function countUnpublished(
+  db: Database.Database,
+  sessionId: string,
+): number {
+  const row = db
+    .prepare(
+      "SELECT COUNT(*) as count FROM turns WHERE session_id = ? AND published = 0",
+    )
+    .get(sessionId) as { count: number };
+  return row.count;
+}
+
+/** Mark turns as in-flight (published=2) to prevent concurrent publish. */
+export function markInFlight(
+  db: Database.Database,
+  sessionId: string,
+  maxId: number,
+  maxRetries: number,
+): void {
+  db.prepare(
+    "UPDATE turns SET published = 2 WHERE session_id = ? AND published = 0 AND retry_count < ? AND id <= ?",
+  ).run(sessionId, maxRetries, maxId);
+}
+
+/** Mark in-flight turns as successfully published (scoped to batch). */
+export function markPublished(db: Database.Database, sessionId: string, maxId: number): void {
+  db.prepare(
+    "UPDATE turns SET published = 1 WHERE session_id = ? AND published = 2 AND id <= ?",
+  ).run(sessionId, maxId);
+}
+
+/** Reset in-flight turns back to unpublished and increment retry count (scoped to batch). */
+export function markFailed(db: Database.Database, sessionId: string, maxId: number): void {
+  db.prepare(
+    "UPDATE turns SET published = 0, retry_count = retry_count + 1 WHERE session_id = ? AND published = 2 AND id <= ?",
+  ).run(sessionId, maxId);
+}
+
+/** Delete published turns older than the given number of days. */
+export function cleanupOldTurns(db: Database.Database, days: number = 7): void {
+  const cutoff = new Date(Date.now() - days * 24 * 60 * 60 * 1000).toISOString();
+  db.prepare(
+    "DELETE FROM turns WHERE published = 1 AND timestamp < ?",
+  ).run(cutoff);
+}

package/plugin/vendor/reflexio/reflexio/integrations/openclaw/plugin/lib/user-id.ts

@@ -0,0 +1,134 @@
+// Multi-user identity resolution.
+//
+// Each Openclaw agent instance maps to a distinct Reflexio user.
+// Resolution chain: env var > session key agentId > openclaw.json > fallback.
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+
+let _openclawConfig: Record<string, unknown> | null = null;
+
+/** Strip JSON5 line and block comments while respecting quoted strings. */
+export function stripJsonComments(raw: string): string {
+  const result: string[] = [];
+  let inBlockComment = false;
+  for (const line of raw.split("\n")) {
+    let out = "";
+    let inString = false;
+    let escape = false;
+    let i = 0;
+    while (i < line.length) {
+      const ch = line[i];
+      if (inBlockComment) {
+        // Look for end of block comment
+        if (ch === "*" && line[i + 1] === "/") {
+          inBlockComment = false;
+          i += 2;
+        } else {
+          i++;
+        }
+        continue;
+      }
+      if (escape) {
+        escape = false;
+        out += ch;
+        i++;
+        continue;
+      }
+      if (inString) {
+        if (ch === "\\") {
+          escape = true;
+          out += ch;
+          i++;
+          continue;
+        }
+        if (ch === '"') {
+          inString = false;
+          out += ch;
+          i++;
+          continue;
+        }
+        out += ch;
+        i++;
+        continue;
+      }
+      // Outside string
+      if (ch === '"') {
+        inString = true;
+        out += ch;
+        i++;
+        continue;
+      }
+      if (ch === "/" && line[i + 1] === "/") {
+        // Line comment — rest of line is comment
+        break;
+      }
+      if (ch === "/" && line[i + 1] === "*") {
+        // Block comment start
+        inBlockComment = true;
+        i += 2;
+        continue;
+      }
+      out += ch;
+      i++;
+    }
+    result.push(out);
+  }
+  return result.join("\n");
+}
+
+/** Read and cache ~/.openclaw/openclaw.json (JSON5 — strip comments before parsing). */
+function loadOpenclawConfig(): Record<string, unknown> {
+  if (_openclawConfig !== null) return _openclawConfig;
+  try {
+    const configPath = path.join(os.homedir(), ".openclaw", "openclaw.json");
+    const raw = fs.readFileSync(configPath, "utf-8");
+    const stripped = stripJsonComments(raw);
+    _openclawConfig = JSON.parse(stripped);
+  } catch {
+    _openclawConfig = {};
+  }
+  return _openclawConfig!;
+}
+
+/**
+ * Resolve the Reflexio user ID.
+ *
+ * @param sessionKey - The Openclaw session key from hook context.
+ * @returns The resolved user ID string.
+ */
+export function resolveUserId(sessionKey: string): string {
+  // 1. Explicit env override
+  if (process.env.REFLEXIO_USER_ID) return process.env.REFLEXIO_USER_ID;
+
+  // 2. Extract agentId from session key (format: agent:<agentId>:<key>)
+  const sessionMatch = sessionKey.match(/^agent:([^:]+):/);
+  if (sessionMatch) return sessionMatch[1];
+
+  // 3. Read openclaw.json
+  const config = loadOpenclawConfig();
+  const agents = config.agents as Record<string, unknown> | undefined;
+  if (agents) {
+    if (typeof agents.defaults === "string") return agents.defaults;
+    if (Array.isArray(agents.list) && agents.list.length > 0) {
+      const first = agents.list[0];
+      if (first && typeof first === "object" && (first as Record<string, unknown>).name) {
+        return (first as Record<string, unknown>).name as string;
+      }
+      if (typeof first === "string") return first;
+    }
+  }
+
+  // 4. Fallback
+  return "openclaw";
+}
+
+/** Resolve the agent version label. */
+export function resolveAgentVersion(): string {
+  return process.env.REFLEXIO_AGENT_VERSION || "openclaw-agent";
+}
+
+/** Reset cached state — for testing only. */
+export function _resetCache(): void {
+  _openclawConfig = null;
+}

package/plugin/vendor/reflexio/reflexio/integrations/openclaw/plugin/openclaw.plugin.json

@@ -0,0 +1,41 @@
+{
+  "id": "reflexio-federated",
+  "name": "Reflexio Federated",
+  "description": "Cross-session memory via Reflexio server. Publishes conversations for extraction, injects relevant profiles and playbooks before each response.",
+  "skills": ["./skills"],
+  "configSchema": {
+    "type": "object",
+    "additionalProperties": false,
+    "properties": {
+      "publish": {
+        "type": "object",
+        "additionalProperties": false,
+        "properties": {
+          "batch_size": { "type": "integer", "default": 10 },
+          "max_retries": { "type": "integer", "default": 3 },
+          "max_content_length": { "type": "integer", "default": 10000 }
+        },
+        "default": { "batch_size": 10, "max_retries": 3, "max_content_length": 10000 }
+      },
+      "search": {
+        "type": "object",
+        "additionalProperties": false,
+        "properties": {
+          "timeout_ms": { "type": "integer", "default": 5000 },
+          "top_k": { "type": "integer", "default": 5 },
+          "min_prompt_length": { "type": "integer", "default": 5 }
+        },
+        "default": { "timeout_ms": 5000, "top_k": 5, "min_prompt_length": 5 }
+      },
+      "server": {
+        "type": "object",
+        "additionalProperties": false,
+        "properties": {
+          "health_check_timeout_ms": { "type": "integer", "default": 3000 },
+          "stale_flag_ms": { "type": "integer", "default": 120000 }
+        },
+        "default": { "health_check_timeout_ms": 3000, "stale_flag_ms": 120000 }
+      }
+    }
+  }
+}

package/plugin/vendor/reflexio/reflexio/integrations/openclaw/plugin/package.json

@@ -0,0 +1,17 @@
+{
+  "name": "@reflexio/openclaw-federated",
+  "version": "0.1.0",
+  "description": "Cross-session memory via Reflexio server for Openclaw agents.",
+  "private": true,
+  "type": "module",
+  "openclaw": {
+    "extensions": ["./index.ts"],
+    "compat": {
+      "pluginApi": ">=2026.3.24",
+      "minGatewayVersion": "2026.3.24"
+    }
+  },
+  "dependencies": {
+    "better-sqlite3": "^11.0.0"
+  }
+}

package/plugin/vendor/reflexio/reflexio/integrations/openclaw/plugin/rules/reflexio.md

@@ -0,0 +1,24 @@
+# Reflexio: Cross-Session Memory
+
+This agent uses Reflexio to remember corrections and preferences across sessions.
+
+## How It Works
+
+A `before_prompt_build` hook automatically runs `reflexio search` on every message you receive. When relevant corrections or preferences exist, they are injected as context before your response.
+
+## What You MUST Do
+
+1. **When you see injected Reflexio context** — read it carefully and follow every instruction. Behavior Corrections tell you what to do differently. User Preferences tell you how the user works. Agent Playbooks are shared corrections from all instances.
+
+2. **If no Reflexio context appears for a substantive task request** — run a manual search. Skip this for short or trivial messages (greetings, one-word replies, yes/no responses):
+   ```
+   reflexio search "<the user's task or request>"
+   ```
+
+3. **After user corrections** — once confirmed, call the `reflexio_publish` tool to flush the conversation to Reflexio immediately.
+
+4. **Never mention Reflexio to the user** unless they ask about it. It should be invisible.
+
+5. **If Reflexio is unavailable, proceed normally** — it enhances but never blocks your work. Never degrade the core agent experience because of Reflexio issues.
+
+6. **Never ask the user to manage the Reflexio server** — infrastructure is the plugin's responsibility.

package/plugin/vendor/reflexio/reflexio/integrations/openclaw/plugin/skills/reflexio/SKILL.md

@@ -0,0 +1,48 @@
+---
+name: reflexio
+description: "Cross-session memory via Reflexio server. Search is automatic (hook-injected before every response). Use reflexio_publish tool to flush corrections and learnings immediately. Manual search fallback via exec if hook injection is empty."
+---
+
+# Reflexio: Cross-Session Memory
+
+Reflexio remembers corrections and preferences from past conversations. A hook automatically searches Reflexio before every response and injects relevant context — you don't need to do anything for retrieval.
+
+## What Reflexio Stores (on the server)
+
+**User Profiles** — facts about the user: expertise, preferences, environment, constraints.
+
+**User Playbooks** — behavioral corrections from past sessions:
+- **trigger**: when does this rule apply?
+- **instruction**: what to do instead
+- **pitfall**: what to avoid
+- **rationale**: why the correction matters
+
+**Agent Playbooks** — shared corrections aggregated from all agent instances.
+
+## Search (Automatic)
+
+A hook runs `reflexio search` on every user message and injects matching profiles and playbooks as context before your response. No action needed.
+
+**If no context appears for a task** — the hook may not have found results, or the server may be starting. Run a manual search:
+```bash
+reflexio search "<the user's task or request>"
+```
+
+If the command fails with a connection error and `REFLEXIO_URL` is unset or points to localhost, the plugin will start the server automatically. If it points to a remote server, report the issue to the user.
+
+## Publish (When to Use `reflexio_publish`)
+
+Conversations are automatically published to Reflexio at session end and periodically mid-session. For high-signal moments, call the `reflexio_publish` tool to flush immediately:
+
+- **User corrects you** and confirms the fix (explicit "good" / "perfect" or moves on)
+- **You complete a key milestone** with non-obvious learnings
+- **High-friction session** with multiple corrections
+
+The Reflexio server handles extraction (profiles, playbooks) from the published conversations. You don't need to structure the data — just publish, and the server does the rest.
+
+## Infrastructure
+
+- The plugin checks and starts the Reflexio server automatically
+- **Never ask the user** to start, stop, or manage the server
+- **Never mention Reflexio** to the user unless they ask
+- If Reflexio is unavailable, proceed normally — it enhances but never blocks