claude-smart 0.2.45 → 0.2.46

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

@@ -1,130 +1,171 @@
-// Reflexio Federated — Openclaw plugin entry.
+// openclaw-smart — TS shim that forwards every openClaw hook to the
+// Python openclaw_smart package via bash + uv.
 //
-// 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 logic lives in src/openclaw_smart/. This file only does SDK wiring.
 //
-// All core logic lives in ./hook/handler.ts — this file is only SDK wiring.
+// Spawn-runner choice: openClaw's runtime currently injects
+// `runtime.system.runCommandWithTimeout` only for *trusted* in-process
+// plugins. User-installed plugins (us) get the runtime without `system`,
+// so capturing it at register-time threw
+// `TypeError: Cannot read properties of undefined (reading 'runCommandWithTimeout')`
+// and prevented our plugin from loading. We spawn via Node's built-in
+// `child_process.spawn` instead, which is not gated by the trust boundary.
 import { definePluginEntry } from "openclaw/plugin-sdk/plugin-entry";
+import { spawn } from "node:child_process";
+import * as path from "node:path";
+import { fileURLToPath } from "node:url";
 
-import {
-  handleBeforePromptBuild,
-  handleMessageSent,
-  handleSessionFlush,
-  handleToolPublish,
-  DEFAULT_CONFIG,
-  type PluginConfig,
-} from "./hook/handler.ts";
+type AnyHandler = (event: unknown, ctx: unknown) => unknown;
 
-// Track the most recently active session key, updated by before_prompt_build and message_sent.
+interface SpawnResult {
+  stdout: string;
+  stderr: string;
+  code: number | null;
+}
+
+// Compiled output lives at <plugin>/dist/index.js; scripts/ + skills/ stay
+// at the plugin root, so we resolve one level up from this module's dir.
+const _MODULE_DIR = path.dirname(fileURLToPath(import.meta.url));
+const PLUGIN_ROOT = path.resolve(_MODULE_DIR, "..");
+const HOOK_ENTRY = path.join(PLUGIN_ROOT, "scripts", "hook_entry.sh");
+
+// Map openClaw hook name → bash event token + per-event timeout (ms).
+//
+// Empirically-verified mapping (Telegram → agent flow, openClaw 2026.5.x):
+//   - message_received        → user message arrived (channel-side)
+//   - before_prompt_build     → final prompt built before model call
+//   - before_tool_call        → agent about to call a tool
+//   - after_tool_call         → tool returned
+//   - agent_end               → agent finished a turn — triggers publish
+//   - session_start/end       → session lifecycle (not always fired)
 //
-// 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 = "";
+// We deliberately exclude:
+//   - Gating hooks (inbound_claim, before_dispatch, reply_dispatch,
+//     before_install) — returning undefined from those is interpreted as
+//     "deny", silently stopping the channel → agent message pipeline.
+//   - Per-token hooks (llm_input, llm_output, model_call_*) — they fire
+//     too often and would spawn a child process per token.
+//
+// before_agent_start / before_agent_reply / before_agent_run all also
+// fire and contain `event.prompt`, but they duplicate the user turn
+// captured by message_received with a "Delivery preamble" prefix —
+// noisier learning input. Stick to message_received for the clean prompt.
+const HOOKS: { name: string; token: string; timeoutMs: number }[] = [
+  { name: "session_start", token: "session-start", timeoutMs: 30000 },
+  { name: "message_received", token: "before-prompt-build", timeoutMs: 15000 },
+  { name: "before_prompt_build", token: "before-prompt-build", timeoutMs: 15000 },
+  { name: "before_tool_call", token: "before-tool-call", timeoutMs: 10000 },
+  { name: "after_tool_call", token: "after-tool-call", timeoutMs: 15000 },
+  { name: "agent_end", token: "agent-end", timeoutMs: 30000 },
+  { name: "session_end", token: "session-end", timeoutMs: 60000 },
+];
 
-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;
+function runScript(
+  argv: string[],
+  opts: { timeoutMs: number; input?: string },
+): Promise<SpawnResult> {
+  return new Promise((resolve) => {
+    const [cmd, ...rest] = argv;
+    const child = spawn(cmd, rest, { stdio: ["pipe", "pipe", "pipe"] });
+    let stdout = "";
+    let stderr = "";
+    let settled = false;
 
-    // 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>) ?? {}) },
+    const finish = (code: number | null) => {
+      if (settled) return;
+      settled = true;
+      if (timer) clearTimeout(timer);
+      resolve({ stdout, stderr, code });
     };
 
-    // 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 timer = setTimeout(() => {
+      try {
+        child.kill("SIGKILL");
+      } catch {
+        // ignore — the close listener still fires.
       }
+      finish(null);
+    }, opts.timeoutMs);
 
-      const result = await handleBeforePromptBuild(
-        sessionKey,
-        agentId,
-        prompt,
-        runner,
-        config,
-        log,
-      );
-
-      if (result.prependSystemContext) {
-        return { prependSystemContext: result.prependSystemContext };
-      }
+    child.stdout.on("data", (d) => {
+      stdout += d.toString();
     });
-
-    // 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,
-      );
+    child.stderr.on("data", (d) => {
+      stderr += d.toString();
     });
+    child.on("error", () => finish(null));
+    child.on("close", (code) => finish(code));
 
-    // before_compaction: flush before transcript is compacted
-    api.on("before_compaction", async (_event, ctx) => {
-      handleSessionFlush(ctx.sessionKey ?? "", log, config);
-    });
+    if (opts.input !== undefined) {
+      child.stdin.write(opts.input);
+    }
+    child.stdin.end();
+  });
+}
 
-    // before_reset: flush before transcript is wiped
-    api.on("before_reset", async (_event, ctx) => {
-      handleSessionFlush(ctx.sessionKey ?? "", log, config);
-    });
+export default definePluginEntry({
+  id: "reflexio-openclaw-smart",
+  name: "Reflexio openClaw Smart",
+  description:
+    "Cross-session memory via reflexio. Publishes conversations for extraction, " +
+    "injects relevant profiles and playbooks before each response.",
+  register(api) {
+    const log = api.logger;
+    const pluginConfig = api.pluginConfig ?? {};
 
-    // session_end: final flush
-    api.on("session_end", async (event, ctx) => {
-      handleSessionFlush(ctx.sessionKey ?? event.sessionKey ?? "", log, config);
-    });
+    log.info?.(
+      `[reflexio-openclaw-smart] register() running; PLUGIN_ROOT=${PLUGIN_ROOT}`,
+    );
 
-    // 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 }] };
-      },
-    });
+    // Hook-only plugin — `openclaw plugins doctor` reports we are on the
+    // supported compatibility path. Force-publish from inside a session is
+    // exposed via the `learn` skill (plugin/skills/learn/SKILL.md).
+    for (const { name, token, timeoutMs } of HOOKS) {
+      const handler: AnyHandler = async (event, ctx) => {
+        const ctxObj = (ctx ?? {}) as { sessionKey?: string };
+        const eventObj = (event ?? {}) as Record<string, unknown>;
+        // For channel-side hooks (e.g. message_received), the user prompt
+        // arrives in event.content; agent-side hooks deliver it in
+        // event.prompt. Normalize to ``prompt`` so the Python handlers stay
+        // simple — they only need to know about one shape.
+        const normalizedPrompt =
+          (eventObj["prompt"] as string | undefined) ??
+          (eventObj["content"] as string | undefined);
+        const payload = {
+          ...(ctxObj as Record<string, unknown>),
+          ...eventObj,
+          ...(normalizedPrompt !== undefined ? { prompt: normalizedPrompt } : {}),
+          plugin_config: pluginConfig,
+        };
+        try {
+          const r = await runScript(
+            ["bash", HOOK_ENTRY, "openclaw", token],
+            { timeoutMs, input: JSON.stringify(payload) },
+          );
+          if (r.code !== 0) {
+            log.debug?.(
+              `[reflexio-openclaw-smart] ${name} exit=${r.code}` +
+                (r.stderr ? ` stderr=${r.stderr.slice(0, 200)}` : ""),
+            );
+            return undefined;
+          }
+          const out = r.stdout.trim();
+          if (!out) return undefined;
+          return JSON.parse(out);
+        } catch (e) {
+          log.debug?.(
+            `[reflexio-openclaw-smart] ${name} failed: ${(e as Error).message}`,
+          );
+          return undefined;
+        }
+      };
+      // Cast: AnyHandler is the most general shape but the SDK's `on` overloads
+      // narrow specific events. We delegate all to the same shell entry point,
+      // so `as never` opts out of the specialized signatures.
+      api.on(name as never, handler as never);
+    }
+    log.info?.(
+      `[reflexio-openclaw-smart] subscribed to ${HOOKS.length} hooks`,
+    );
   },
 });

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

@@ -1,8 +1,11 @@
 {
-  "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.",
+  "id": "reflexio-openclaw-smart",
+  "name": "Reflexio openClaw Smart",
+  "description": "Cross-session memory and self-improvement for openClaw via local reflexio backend.",
   "skills": ["./skills"],
+  "activation": {
+    "onStartup": true
+  },
   "configSchema": {
     "type": "object",
     "additionalProperties": false,
@@ -14,18 +17,16 @@
           "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 },
+          "top_k": { "type": "integer", "default": 3 },
           "min_prompt_length": { "type": "integer", "default": 5 }
-        },
-        "default": { "timeout_ms": 5000, "top_k": 5, "min_prompt_length": 5 }
+        }
       },
       "server": {
         "type": "object",
@@ -33,8 +34,17 @@
         "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 }
+        }
+      },
+      "extraction": {
+        "type": "object",
+        "additionalProperties": false,
+        "properties": {
+          "model": {
+            "type": "string",
+            "description": "openClaw model id passed as --model to `openclaw infer model run`. If omitted, the user's openClaw default is used."
+          }
+        }
       }
     }
   }

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

@@ -1,17 +1,39 @@
 {
-  "name": "@reflexio/openclaw-federated",
+  "name": "@reflexioai/openclaw-smart",
   "version": "0.1.0",
-  "description": "Cross-session memory via Reflexio server for Openclaw agents.",
-  "private": true,
+  "description": "Self-improving openClaw plugin — learns from corrections across sessions via reflexio.",
   "type": "module",
+  "bin": {
+    "openclaw-smart": "./scripts/npm-cli.js"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.build.json",
+    "prepack": "npm run build",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "typecheck": "tsc --noEmit"
+  },
   "openclaw": {
-    "extensions": ["./index.ts"],
+    "extensions": ["./dist/index.js"],
     "compat": {
       "pluginApi": ">=2026.3.24",
       "minGatewayVersion": "2026.3.24"
     }
   },
-  "dependencies": {
-    "better-sqlite3": "^11.0.0"
+  "files": [
+    "dist/**/*.js",
+    "scripts/**/*",
+    "skills/**/*",
+    "src/**/*.py",
+    "types/**/*.d.ts",
+    "openclaw.plugin.json",
+    "pyproject.toml",
+    "uv.lock",
+    "README.md"
+  ],
+  "devDependencies": {
+    "@types/node": "^20.0.0",
+    "typescript": "^5.0.0",
+    "vitest": "^3.0.0"
   }
 }

package/plugin/vendor/reflexio/reflexio/integrations/openclaw/plugin/pyproject.toml

@@ -0,0 +1,42 @@
+[project]
+name = "openclaw-smart"
+version = "0.1.0"
+description = "openClaw plugin: cross-session memory via local reflexio backend"
+readme = "README.md"
+requires-python = ">=3.12"
+dependencies = [
+    "reflexio-ai",
+    # Used by reflexio's local embedding provider (ONNXMiniLM_L6_V2).
+    "chromadb>=0.5",
+    "einops>=0.8.0",
+]
+
+[project.scripts]
+openclaw-smart-hook = "openclaw_smart.hook:main"
+openclaw-smart = "openclaw_smart.cli:main"
+openclaw-smart-optimizer-assistant = "openclaw_smart.optimizer_assistant:main"
+
+[tool.uv.sources]
+# This plugin lives inside the reflexio repo; depend on the local reflexio
+# package directly, not the PyPI release. Path is from plugin/ → up 4 levels
+# to the open_source/reflexio submodule root.
+reflexio-ai = { path = "../../../..", editable = true }
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/openclaw_smart"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+markers = [
+    "integration: tests that depend on shared state or a running reflexio backend",
+    "e2e: end-to-end tests that drive the full hook pipeline",
+]
+
+[dependency-groups]
+dev = [
+    "pytest>=9.0.3",
+]