claude-smart 0.2.41 → 0.2.43

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

@@ -0,0 +1,18 @@
+{
+  "name": "openclaw-federated-dev",
+  "version": "0.1.0",
+  "private": true,
+  "type": "module",
+  "scripts": {
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "typecheck": "tsc --noEmit"
+  },
+  "devDependencies": {
+    "@types/better-sqlite3": "^7.0.0",
+    "@types/node": "^20.0.0",
+    "better-sqlite3": "^11.0.0",
+    "typescript": "^5.0.0",
+    "vitest": "^3.0.0"
+  }
+}

package/plugin/vendor/reflexio/reflexio/integrations/openclaw/plugin/hook/handler.ts

@@ -0,0 +1,241 @@
+// Core hook logic: search injection, message buffering, session flush.
+//
+// Decoupled from the Plugin SDK so each handler can be tested independently.
+// The SDK wiring in index.ts calls these functions with injected deps.
+import * as os from "node:os";
+import * as path from "node:path";
+import type Database from "better-sqlite3";
+import {
+  openDb,
+  insertTurn,
+  countUnpublished,
+  cleanupOldTurns,
+  getOldUnpublishedSessions,
+} from "../lib/sqlite-buffer.ts";
+import { publishSession } from "../lib/publish.ts";
+import { shouldSkipSearch, runSearch, isConnectionError } from "../lib/search.ts";
+import { ensureServerRunning, type CommandRunner } from "../lib/server.ts";
+import { resolveUserId, resolveAgentVersion } from "../lib/user-id.ts";
+import { runSetupCheck, type SetupGuidance } from "./setup.ts";
+
+type Logger = {
+  info?: (msg: string) => void;
+  warn?: (msg: string) => void;
+  error?: (msg: string) => void;
+};
+
+export interface PluginConfig {
+  publish: { batch_size: number; max_retries: number; max_content_length: number };
+  search: { timeout_ms: number; top_k: number; min_prompt_length: number };
+  server: { health_check_timeout_ms: number; stale_flag_ms: number };
+}
+
+export const DEFAULT_CONFIG: PluginConfig = {
+  publish: { batch_size: 10, max_retries: 3, max_content_length: 10_000 },
+  search: { timeout_ms: 5_000, top_k: 5, min_prompt_length: 5 },
+  server: { health_check_timeout_ms: 3_000, stale_flag_ms: 120_000 },
+};
+
+const DB_PATH = path.join(os.homedir(), ".reflexio", "sessions.db");
+const MAX_INTERACTIONS = 200;
+const MAX_OLD_SESSIONS = 5;
+
+let _db: Database.Database | null = null;
+
+function getDb(): Database.Database {
+  if (!_db) {
+    _db = openDb(DB_PATH);
+    cleanupOldTurns(_db, 7);
+    process.on("exit", () => {
+      if (_db) _db.close();
+    });
+  }
+  return _db;
+}
+
+/**
+ * Handle before_prompt_build: auto-setup, search injection, retry old sessions.
+ * Returns prependSystemContext string if search results found.
+ */
+export async function handleBeforePromptBuild(
+  sessionKey: string,
+  agentId: string,
+  prompt: string | undefined,
+  runner: CommandRunner,
+  config: PluginConfig = DEFAULT_CONFIG,
+  log?: Logger,
+): Promise<{ prependSystemContext?: string; setupGuidance?: SetupGuidance }> {
+  // 1. Auto-setup check
+  let guidance: SetupGuidance | null = null;
+  try {
+    guidance = await runSetupCheck(agentId);
+  } catch (err) {
+    log?.error?.(`[reflexio] Setup check failed: ${err}`);
+  }
+  if (guidance) {
+    return {
+      prependSystemContext: `# Reflexio Setup Required\n\n${guidance.message}`,
+      setupGuidance: guidance,
+    };
+  }
+
+  // 2. Ensure server is running
+  try {
+    await ensureServerRunning(runner, {
+      staleFlagMs: config.server.stale_flag_ms,
+      log,
+    });
+  } catch (err) {
+    log?.error?.(`[reflexio] Server check failed: ${err}`);
+  }
+
+  // 3. Retry unpublished turns from old sessions
+  try {
+    const db = getDb();
+    const agentVersion = resolveAgentVersion();
+    const oldSessions = getOldUnpublishedSessions(
+      db,
+      sessionKey,
+      config.publish.max_retries,
+      MAX_OLD_SESSIONS,
+    );
+    for (const sid of oldSessions) {
+      const userId = resolveUserId(sid);
+      publishSession(
+        db,
+        sid,
+        userId,
+        agentVersion,
+        config.publish.max_retries,
+        MAX_INTERACTIONS,
+        log,
+      );
+    }
+  } catch (err) {
+    log?.error?.(`[reflexio] Old session retry failed: ${err}`);
+  }
+
+  // 4. Search injection
+  if (!prompt || shouldSkipSearch(prompt, config.search.min_prompt_length)) {
+    return {};
+  }
+
+  try {
+    const userId = resolveUserId(sessionKey);
+    const context = await runSearch(
+      prompt,
+      userId,
+      config.search.top_k,
+      config.search.timeout_ms,
+      runner,
+    );
+    if (context) {
+      return { prependSystemContext: context };
+    }
+  } catch (err) {
+    const errMsg = String(err);
+    log?.error?.(`[reflexio] Search failed: ${errMsg}`);
+    if (isConnectionError(errMsg)) {
+      try {
+        await ensureServerRunning(runner, { staleFlagMs: config.server.stale_flag_ms, log });
+      } catch {}
+    }
+  }
+
+  return {};
+}
+
+/**
+ * Handle message_sent: buffer turn to SQLite, trigger incremental publish.
+ */
+export function handleMessageSent(
+  sessionKey: string,
+  userMessage: string | undefined,
+  agentResponse: string | undefined,
+  runner: CommandRunner,
+  config: PluginConfig = DEFAULT_CONFIG,
+  log?: Logger,
+): void {
+  if (!userMessage && !agentResponse) return;
+
+  try {
+    const db = getDb();
+    const maxLen = config.publish.max_content_length;
+    if (userMessage) insertTurn(db, sessionKey, "user", userMessage, maxLen);
+    if (agentResponse) insertTurn(db, sessionKey, "assistant", agentResponse, maxLen);
+
+    // Incremental publish at batch threshold
+    const count = countUnpublished(db, sessionKey);
+    if (count >= config.publish.batch_size * 2) {
+      const userId = resolveUserId(sessionKey);
+      const agentVersion = resolveAgentVersion();
+      publishSession(
+        db,
+        sessionKey,
+        userId,
+        agentVersion,
+        config.publish.max_retries,
+        MAX_INTERACTIONS,
+        log,
+      );
+    }
+  } catch (err) {
+    log?.error?.(`[reflexio] Failed to buffer turn: ${err}`);
+  }
+}
+
+/**
+ * Handle session end / compaction / reset: flush all unpublished turns.
+ */
+export function handleSessionFlush(
+  sessionKey: string,
+  log?: Logger,
+  config: PluginConfig = DEFAULT_CONFIG,
+): void {
+  try {
+    const db = getDb();
+    const userId = resolveUserId(sessionKey);
+    const agentVersion = resolveAgentVersion();
+    publishSession(
+      db,
+      sessionKey,
+      userId,
+      agentVersion,
+      config.publish.max_retries,
+      MAX_INTERACTIONS,
+      log,
+    );
+  } catch (err) {
+    log?.error?.(`[reflexio] Session flush failed: ${err}`);
+  }
+}
+
+/**
+ * Handle reflexio_publish tool: immediate flush of current session.
+ */
+export function handleToolPublish(
+  sessionKey: string,
+  log?: Logger,
+  config: PluginConfig = DEFAULT_CONFIG,
+): string {
+  try {
+    const db = getDb();
+    const count = countUnpublished(db, sessionKey);
+    if (count === 0) return "No unpublished turns to flush.";
+
+    const userId = resolveUserId(sessionKey);
+    const agentVersion = resolveAgentVersion();
+    publishSession(
+      db,
+      sessionKey,
+      userId,
+      agentVersion,
+      config.publish.max_retries,
+      MAX_INTERACTIONS,
+      log,
+    );
+    return `Flushing ${count} turns to Reflexio server.`;
+  } catch (err) {
+    return `Publish failed: ${err}`;
+  }
+}

package/plugin/vendor/reflexio/reflexio/integrations/openclaw/plugin/hook/setup.ts

@@ -0,0 +1,140 @@
+// Runtime auto-setup: check reflexio CLI, check config, check server.
+//
+// Runs on before_prompt_build. Gated by per-agent marker file.
+// Each step that fails returns a guidance message for the agent to present
+// to the user with options — the user picks, Openclaw executes.
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+import { execFile, execFileSync } from "node:child_process";
+
+export interface SetupGuidance {
+  /** Message for the agent to present to the user. */
+  message: string;
+  /** Whether the plugin can function without resolving this. */
+  blocking: boolean;
+}
+
+const REFLEXIO_DIR = path.join(os.homedir(), ".reflexio");
+
+/** Sanitize agentId for safe use in filesystem paths. */
+function sanitizeAgentId(agentId: string): string {
+  return agentId.replace(/[^a-zA-Z0-9_-]/g, "_");
+}
+
+/** Check if setup has been completed for a given agent. */
+export function isSetupComplete(reflexioDir: string, agentId: string): boolean {
+  const safeId = sanitizeAgentId(agentId);
+  const marker = path.join(reflexioDir, `.setup_complete_${safeId}`);
+  return fs.existsSync(marker);
+}
+
+/** Create the setup-complete marker for an agent. */
+export function markSetupComplete(reflexioDir: string, agentId: string): void {
+  const safeId = sanitizeAgentId(agentId);
+  fs.mkdirSync(reflexioDir, { recursive: true });
+  fs.writeFileSync(
+    path.join(reflexioDir, `.setup_complete_${safeId}`),
+    new Date().toISOString(),
+  );
+}
+
+/** Check if `reflexio` CLI is available on PATH. */
+export function checkReflexioInstalled(): Promise<boolean> {
+  return new Promise((resolve) => {
+    execFile(
+      "reflexio",
+      ["--version"],
+      { timeout: 5_000 },
+      (err) => { resolve(err === null); },
+    );
+  });
+}
+
+/** Detect which Python package installer is available. */
+export function detectInstaller(): "pipx" | "pip" | null {
+  try {
+    execFileSync("pipx", ["--version"], { timeout: 3_000, stdio: ["ignore", "pipe", "pipe"] });
+    return "pipx";
+  } catch {
+    // pipx not found
+  }
+  try {
+    execFileSync("pip", ["--version"], { timeout: 3_000, stdio: ["ignore", "pipe", "pipe"] });
+    return "pip";
+  } catch {
+    // pip not found
+  }
+  return null;
+}
+
+/** Check if Reflexio has been configured (~/.reflexio/.env with REFLEXIO_URL). */
+export function checkReflexioConfigured(reflexioDir: string = REFLEXIO_DIR): boolean {
+  try {
+    const envPath = path.join(reflexioDir, ".env");
+    const content = fs.readFileSync(envPath, "utf-8");
+    return content.split("\n").some((line) => {
+      const trimmed = line.trim();
+      if (trimmed.startsWith("#")) return false;
+      const match = trimmed.match(/^REFLEXIO_URL\s*=\s*"?([^"\s]+)/);
+      return match !== null && match[1].length > 0;
+    });
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Run the full setup check chain. Returns guidance for the agent if setup
+ * is incomplete, or null if everything is ready.
+ */
+export async function runSetupCheck(
+  agentId: string,
+  reflexioDir: string = REFLEXIO_DIR,
+): Promise<SetupGuidance | null> {
+  // Gate: already set up?
+  if (isSetupComplete(reflexioDir, agentId)) return null;
+
+  // Step 1: Is reflexio installed?
+  const installed = await checkReflexioInstalled();
+  if (!installed) {
+    const installer = detectInstaller();
+    if (installer === "pipx") {
+      return {
+        message:
+          "Reflexio CLI is required but not found. " +
+          "I can install it via pipx. OK if I run `pipx install reflexio-ai`?",
+        blocking: true,
+      };
+    }
+    if (installer === "pip") {
+      return {
+        message:
+          "Reflexio CLI is required but not found. " +
+          "I can install it via pip. OK if I run `pip install reflexio-ai`? " +
+          "(If this fails on macOS, I'll guide you through pipx instead.)",
+        blocking: true,
+      };
+    }
+    return {
+      message:
+        "Reflexio CLI is required but not found, and neither pipx nor pip is available. " +
+        "Please install pipx first (https://pipx.pypa.io/), then I can install Reflexio for you.",
+      blocking: true,
+    };
+  }
+
+  // Step 2: Is Reflexio configured?
+  if (!checkReflexioConfigured(reflexioDir)) {
+    return {
+      message:
+        "Reflexio needs initial configuration (storage backend, LLM provider). " +
+        "OK if I run `reflexio setup init` to start the setup wizard?",
+      blocking: true,
+    };
+  }
+
+  // All checks passed — create marker
+  markSetupComplete(reflexioDir, agentId);
+  return null;
+}

package/plugin/vendor/reflexio/reflexio/integrations/openclaw/plugin/index.ts

@@ -0,0 +1,130 @@
+// Reflexio Federated — Openclaw plugin entry.
+//
+// Registers lifecycle hooks and one tool against the Openclaw Plugin API:
+//   - before_prompt_build: auto-setup, search injection, retry old sessions
+//   - message_sent:        buffer turn to SQLite, incremental publish
+//   - before_compaction:   flush unpublished turns before transcript is lost
+//   - before_reset:        flush unpublished turns before transcript is wiped
+//   - session_end:         final flush of all remaining turns
+//   - reflexio_publish:    agent-invoked immediate flush
+//
+// All core logic lives in ./hook/handler.ts — this file is only SDK wiring.
+import { definePluginEntry } from "openclaw/plugin-sdk/plugin-entry";
+
+import {
+  handleBeforePromptBuild,
+  handleMessageSent,
+  handleSessionFlush,
+  handleToolPublish,
+  DEFAULT_CONFIG,
+  type PluginConfig,
+} from "./hook/handler.ts";
+
+// Track the most recently active session key, updated by before_prompt_build and message_sent.
+//
+// LIMITATION: This is a process-global variable. The Openclaw Plugin SDK does not pass session
+// context into the tool `execute` callback, so `reflexio_publish` can only target the most
+// recently active session. If multiple sessions run concurrently in the same process, this value
+// will reflect whichever session fired last — meaning `reflexio_publish` may flush the wrong
+// session's turns. This plugin is designed for single-session use. Concurrent multi-session
+// support would require the Plugin SDK to expose session context in the tool execute callback.
+let _activeSessionKey = "";
+
+export default definePluginEntry({
+  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.",
+  register(api) {
+    const log = api.logger;
+    const runner = api.runtime.system.runCommandWithTimeout;
+
+    // Merge user config with defaults
+    const rawConfig = (api.pluginConfig ?? {}) as Record<string, unknown>;
+    const config: PluginConfig = {
+      publish: { ...DEFAULT_CONFIG.publish, ...((rawConfig.publish as Record<string, number>) ?? {}) },
+      search: { ...DEFAULT_CONFIG.search, ...((rawConfig.search as Record<string, number>) ?? {}) },
+      server: { ...DEFAULT_CONFIG.server, ...((rawConfig.server as Record<string, number>) ?? {}) },
+    };
+
+    // before_prompt_build: setup, search, retry
+    api.on("before_prompt_build", async (_event: unknown, ctx: unknown) => {
+      const context = ctx as { agentId?: string; sessionKey?: string };
+      const sessionKey = context.sessionKey ?? "";
+      const agentId = context.agentId ?? "main";
+      if (sessionKey) _activeSessionKey = sessionKey;
+
+      // Extract prompt from event (best-effort)
+      const eventObj = _event as { prompt?: string; messages?: { role?: string; content?: unknown }[] };
+      let prompt = eventObj.prompt;
+      if (!prompt && Array.isArray(eventObj.messages)) {
+        const lastUser = [...eventObj.messages].reverse().find((m) => m.role === "user");
+        if (lastUser) {
+          prompt = typeof lastUser.content === "string"
+            ? lastUser.content
+            : JSON.stringify(lastUser.content);
+        }
+      }
+
+      const result = await handleBeforePromptBuild(
+        sessionKey,
+        agentId,
+        prompt,
+        runner,
+        config,
+        log,
+      );
+
+      if (result.prependSystemContext) {
+        return { prependSystemContext: result.prependSystemContext };
+      }
+    });
+
+    // message_sent: buffer turn to SQLite
+    api.on("message_sent", (_event: unknown, ctx: unknown) => {
+      const context = ctx as { sessionKey?: string };
+      const event = _event as { userMessage?: string; agentResponse?: string; content?: string; role?: string };
+      const sessionKey = context.sessionKey ?? "";
+      if (sessionKey) _activeSessionKey = sessionKey;
+      handleMessageSent(
+        sessionKey,
+        event.userMessage,
+        event.agentResponse ?? (event.role === "assistant" ? (typeof event.content === "string" ? event.content : undefined) : undefined),
+        runner,
+        config,
+        log,
+      );
+    });
+
+    // before_compaction: flush before transcript is compacted
+    api.on("before_compaction", async (_event, ctx) => {
+      handleSessionFlush(ctx.sessionKey ?? "", log, config);
+    });
+
+    // before_reset: flush before transcript is wiped
+    api.on("before_reset", async (_event, ctx) => {
+      handleSessionFlush(ctx.sessionKey ?? "", log, config);
+    });
+
+    // session_end: final flush
+    api.on("session_end", async (event, ctx) => {
+      handleSessionFlush(ctx.sessionKey ?? event.sessionKey ?? "", log, config);
+    });
+
+    // reflexio_publish tool: agent-invoked immediate flush
+    api.registerTool({
+      name: "reflexio_publish",
+      description:
+        "Immediately publish all buffered conversation turns to the Reflexio server. " +
+        "Use after user corrections, key milestones, or high-signal moments when you " +
+        "don't want to wait for the automatic session-end publish.",
+      parameters: { type: "object", properties: {} },
+      optional: true,
+      async execute(_id: string, _params: Record<string, unknown>) {
+        // Use the module-level active session key tracked by before_prompt_build and message_sent.
+        const result = handleToolPublish(_activeSessionKey, log, config);
+        return { content: [{ type: "text" as const, text: result }] };
+      },
+    });
+  },
+});

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

@@ -0,0 +1,113 @@
+// Build payload and spawn `reflexio interactions publish`.
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+import { spawn } from "node:child_process";
+import type Database from "better-sqlite3";
+import type { Turn } from "./sqlite-buffer.ts";
+import {
+  getUnpublished,
+  markInFlight,
+  markPublished,
+  markFailed,
+} from "./sqlite-buffer.ts";
+
+type Logger = {
+  info?: (msg: string) => void;
+  error?: (msg: string) => void;
+};
+
+const PAYLOAD_DIR = path.join(os.homedir(), ".reflexio", "tmp");
+
+/** Build a JSON payload string from turns. */
+export function buildPayload(
+  turns: Turn[],
+  userId: string,
+  agentVersion: string,
+  sessionId: string,
+): string {
+  return JSON.stringify({
+    user_id: userId,
+    source: "openclaw",
+    agent_version: agentVersion,
+    session_id: sessionId,
+    interactions: turns.map((t) => ({ role: t.role, content: t.content })),
+  });
+}
+
+/** Sanitize a string for use in a filename. */
+function sanitizeFilename(name: string): string {
+  return name.replace(/[^a-zA-Z0-9_-]/g, "_").replace(/^-+/, "").slice(0, 100) || "unnamed";
+}
+
+/**
+ * Publish unpublished turns for a session. Fire-and-forget spawn of CLI.
+ * Marks turns in-flight before spawning, then published/failed on exit.
+ */
+export function publishSession(
+  db: Database.Database,
+  sessionId: string,
+  userId: string,
+  agentVersion: string,
+  maxRetries: number,
+  maxInteractions: number,
+  log?: Logger,
+): void {
+  const turns = getUnpublished(db, sessionId, maxRetries, maxInteractions);
+  if (turns.length === 0) return;
+
+  const maxId = turns[turns.length - 1].id;
+  markInFlight(db, sessionId, maxId, maxRetries);
+
+  const payload = buildPayload(turns, userId, agentVersion, sessionId);
+
+  fs.mkdirSync(PAYLOAD_DIR, { recursive: true, mode: 0o700 });
+  const payloadFile = path.join(
+    PAYLOAD_DIR,
+    `publish-${sanitizeFilename(sessionId)}-${Date.now()}.json`,
+  );
+  fs.writeFileSync(payloadFile, payload, { mode: 0o600 });
+
+  const child = spawn(
+    "reflexio",
+    ["interactions", "publish", "--file", payloadFile],
+    { stdio: ["ignore", "ignore", "ignore"], detached: true },
+  );
+
+  child.on("error", (err) => {
+    log?.error?.(`[reflexio] Failed to spawn reflexio binary: ${err.message}`);
+    try {
+      markFailed(db, sessionId, maxId);
+    } catch (dbErr) {
+      log?.error?.(`[reflexio] Failed to update retry count after spawn error: ${dbErr}`);
+    }
+    try {
+      fs.unlinkSync(payloadFile);
+    } catch {}
+  });
+
+  child.on("close", (code) => {
+    if (code === 0) {
+      try {
+        markPublished(db, sessionId, maxId);
+      } catch (err) {
+        log?.error?.(`[reflexio] Failed to mark turns published: ${err}`);
+      }
+    } else {
+      log?.error?.(`[reflexio] Publish failed (exit ${code}), incrementing retry`);
+      try {
+        markFailed(db, sessionId, maxId);
+      } catch (err) {
+        log?.error?.(`[reflexio] Failed to update retry count: ${err}`);
+      }
+    }
+    try {
+      fs.unlinkSync(payloadFile);
+    } catch {}
+  });
+  child.unref();
+
+  log?.info?.(
+    `[reflexio] Queued ${turns.length} turns for publish (session ${sessionId})`,
+  );
+}

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

@@ -0,0 +1,52 @@
+// Search Reflexio and format results for context injection.
+import type { CommandRunner } from "./server.ts";
+
+const TRIVIAL_RE = /^(yes|no|ok|okay|sure|thanks|thank you|yep|nope|right|correct|got it|done|good|great|fine|lgtm|y|n|k|ty|thx|ack|np)$/i;
+
+/** Decide whether to skip search for a given message. */
+export function shouldSkipSearch(prompt: string, minLength: number): boolean {
+  if (!prompt || prompt.length < minLength) return true;
+  return TRIVIAL_RE.test(prompt.trim());
+}
+
+/** Format raw search output for context injection. Returns null if empty/no results. */
+export function formatSearchContext(raw: string): string | null {
+  const trimmed = raw.trim();
+  if (!trimmed) return null;
+  if (trimmed.includes("Found 0 profiles, 0 playbooks")) return null;
+  return trimmed;
+}
+
+/**
+ * Run `reflexio search` and return formatted context string.
+ * Returns null if no results.
+ * Throws an Error (with stderr as message) on non-zero exit code so callers can
+ * distinguish connection/binary errors from empty-results.
+ */
+export async function runSearch(
+  prompt: string,
+  userId: string,
+  topK: number,
+  timeoutMs: number,
+  runner: CommandRunner,
+): Promise<string | null> {
+  const result = await runner(
+    ["reflexio", "search", prompt.slice(0, 4096), "--user-id", userId, "--top-k", String(topK)],
+    { timeoutMs },
+  );
+  if (result.code !== 0) {
+    throw new Error(result.stderr || `reflexio search exited with code ${result.code}`);
+  }
+  return formatSearchContext(result.stdout);
+}
+
+/**
+ * Check if a search failure looks like a connection error.
+ */
+export function isConnectionError(errMsg: string): boolean {
+  return (
+    errMsg.includes("Cannot reach server") ||
+    errMsg.includes("Connection refused") ||
+    errMsg.includes("ECONNREFUSED")
+  );
+}