claude-smart 0.2.42 → 0.2.44

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

@@ -0,0 +1,91 @@
+import { describe, it, expect, beforeEach, afterEach } from "vitest";
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+import {
+  openDb,
+  insertTurn,
+  getUnpublished,
+  markInFlight,
+  markPublished,
+  markFailed,
+  smartTruncate,
+  cleanupOldTurns,
+} from "../plugin/lib/sqlite-buffer.ts";
+import type Database from "better-sqlite3";
+
+describe("smartTruncate", () => {
+  it("returns content unchanged when under limit", () => {
+    expect(smartTruncate("hello", 100)).toBe("hello");
+  });
+
+  it("truncates with head + marker + tail within maxLength", () => {
+    const content = "a".repeat(200);
+    const result = smartTruncate(content, 100);
+    expect(result.length).toBeLessThanOrEqual(100);
+    expect(result).toContain("[...truncated");
+  });
+
+  it("returns empty string for empty input", () => {
+    expect(smartTruncate("", 100)).toBe("");
+  });
+});
+
+describe("sqlite-buffer", () => {
+  let db: Database.Database;
+  let tmpDir: string;
+
+  beforeEach(() => {
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "reflexio-test-"));
+    const dbPath = path.join(tmpDir, "sessions.db");
+    db = openDb(dbPath);
+  });
+
+  afterEach(() => {
+    db.close();
+    fs.rmSync(tmpDir, { recursive: true, force: true });
+  });
+
+  it("inserts and retrieves turns", () => {
+    insertTurn(db, "sess1", "user", "hello");
+    insertTurn(db, "sess1", "assistant", "hi there");
+    const turns = getUnpublished(db, "sess1", 3, 100);
+    expect(turns).toHaveLength(2);
+    expect(turns[0].role).toBe("user");
+    expect(turns[1].role).toBe("assistant");
+  });
+
+  it("marks turns as in-flight then published", () => {
+    insertTurn(db, "sess1", "user", "hello");
+    const turns = getUnpublished(db, "sess1", 3, 100);
+    const maxId = turns[turns.length - 1].id;
+    markInFlight(db, "sess1", maxId, 3);
+    expect(getUnpublished(db, "sess1", 3, 100)).toHaveLength(0);
+    markPublished(db, "sess1", maxId);
+    expect(getUnpublished(db, "sess1", 3, 100)).toHaveLength(0);
+  });
+
+  it("increments retry count on failure", () => {
+    insertTurn(db, "sess1", "user", "hello");
+    const turns = getUnpublished(db, "sess1", 3, 100);
+    const id = turns[0].id;
+    markInFlight(db, "sess1", id, 3);
+    markFailed(db, "sess1", id);
+    const after = getUnpublished(db, "sess1", 3, 100);
+    expect(after).toHaveLength(1);
+    // After MAX_RETRIES failures, turn should be excluded
+    markInFlight(db, "sess1", id, 3);
+    markFailed(db, "sess1", id);
+    markInFlight(db, "sess1", id, 3);
+    markFailed(db, "sess1", id);
+    expect(getUnpublished(db, "sess1", 3, 100)).toHaveLength(0);
+  });
+
+  it("respects max interactions limit", () => {
+    for (let i = 0; i < 10; i++) {
+      insertTurn(db, "sess1", "user", `msg ${i}`);
+    }
+    const turns = getUnpublished(db, "sess1", 3, 5);
+    expect(turns).toHaveLength(5);
+  });
+});

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

@@ -0,0 +1,50 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
+import { resolveUserId, stripJsonComments, _resetCache } from "../plugin/lib/user-id.ts";
+
+describe("stripJsonComments", () => {
+  it("strips line comments", () => {
+    expect(stripJsonComments('{ "key": "val" } // comment')).toBe('{ "key": "val" } ');
+  });
+
+  it("preserves URLs in quoted strings", () => {
+    expect(stripJsonComments('{ "url": "http://example.com" }')).toBe(
+      '{ "url": "http://example.com" }',
+    );
+  });
+
+  it("strips comment after quoted string containing //", () => {
+    expect(stripJsonComments('{ "url": "http://x.com" } // note')).toBe(
+      '{ "url": "http://x.com" } ',
+    );
+  });
+});
+
+describe("resolveUserId", () => {
+  const originalEnv = process.env;
+
+  beforeEach(() => {
+    process.env = { ...originalEnv };
+    _resetCache();
+  });
+
+  afterEach(() => {
+    process.env = originalEnv;
+  });
+
+  it("returns REFLEXIO_USER_ID env var if set", () => {
+    process.env.REFLEXIO_USER_ID = "custom-user";
+    expect(resolveUserId("agent:main:abc123")).toBe("custom-user");
+  });
+
+  it("extracts agentId from session key format agent:<id>:<key>", () => {
+    expect(resolveUserId("agent:work:session789")).toBe("work");
+  });
+
+  it("falls back to 'openclaw' when no session key or env", () => {
+    expect(resolveUserId("")).toBe("openclaw");
+  });
+
+  it("falls back to 'openclaw' for non-agent session key format", () => {
+    expect(resolveUserId("random-session-key")).toBe("openclaw");
+  });
+});

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

@@ -0,0 +1,16 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "NodeNext",
+    "moduleResolution": "NodeNext",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "noEmit": true,
+    "allowImportingTsExtensions": true,
+    "resolveJsonModule": true,
+    "types": ["node"]
+  },
+  "include": ["plugin/**/*.ts", "types/**/*.d.ts"],
+  "exclude": ["tests", "node_modules"]
+}

package/plugin/vendor/reflexio/reflexio/integrations/openclaw/types/openclaw.d.ts

@@ -0,0 +1,230 @@
+// Narrow ambient shim for the Openclaw Plugin SDK surface that this plugin
+// actually touches. The real types ship with the `openclaw` npm package, but
+// we avoid depending on the full host at build time — plugins load at runtime
+// via the host's own jiti instance.
+//
+// If you need richer type coverage, install `openclaw` as a devDependency and
+// delete this file; the real .d.ts files will take over.
+declare module "openclaw/plugin-sdk/plugin-entry" {
+  export type PluginHookName =
+    | "before_model_resolve"
+    | "before_prompt_build"
+    | "before_agent_start"
+    | "before_agent_reply"
+    | "llm_input"
+    | "llm_output"
+    | "agent_end"
+    | "before_compaction"
+    | "after_compaction"
+    | "before_reset"
+    | "inbound_claim"
+    | "message_received"
+    | "message_sending"
+    | "message_sent"
+    | "before_tool_call"
+    | "after_tool_call"
+    | "tool_result_persist"
+    | "before_message_write"
+    | "session_start"
+    | "session_end"
+    | "subagent_spawning"
+    | "subagent_delivery_target"
+    | "subagent_spawned"
+    | "subagent_ended"
+    | "gateway_start"
+    | "gateway_stop"
+    | "before_dispatch"
+    | "reply_dispatch"
+    | "before_install";
+
+  export type PluginLogger = {
+    info?: (msg: string) => void;
+    warn?: (msg: string) => void;
+    error?: (msg: string) => void;
+    debug?: (msg: string) => void;
+  };
+
+  export type PluginRuntime = {
+    subagent?: {
+      run: (params: {
+        sessionKey: string;
+        message: string;
+        provider?: string;
+        model?: string;
+        extraSystemPrompt?: string;
+        lane?: string;
+        deliver?: boolean;
+        idempotencyKey?: string;
+      }) => Promise<{ runId: string }>;
+    };
+    system: {
+      runCommandWithTimeout: (
+        argv: string[],
+        opts: { timeoutMs: number; input?: string },
+      ) => Promise<{ stdout: string; stderr: string; code: number | null }>;
+    };
+    config: {
+      loadConfig: () => unknown;
+    };
+  };
+
+  export type PluginHookAgentContext = {
+    runId?: string;
+    agentId?: string;
+    sessionKey?: string;
+    sessionId?: string;
+    workspaceDir?: string;
+  };
+
+  export type PluginHookSessionContext = {
+    agentId?: string;
+    sessionId: string;
+    sessionKey?: string;
+    workspaceDir?: string;
+  };
+
+  export type PluginHookBeforeAgentStartEvent = {
+    prompt: string;
+    messages?: unknown[];
+  };
+
+  export type PluginHookBeforeAgentStartResult = {
+    prependSystemContext?: string;
+    systemPrompt?: string;
+    prependContext?: string;
+    appendSystemContext?: string;
+    modelOverride?: string;
+    providerOverride?: string;
+  };
+
+  export type PluginHookBeforeCompactionEvent = {
+    messageCount: number;
+    compactingCount?: number;
+    tokenCount?: number;
+    messages?: unknown[];
+    sessionFile?: string;
+  };
+
+  export type PluginHookBeforeResetEvent = {
+    sessionFile?: string;
+    messages?: unknown[];
+    reason?: string;
+  };
+
+  export type PluginHookSessionEndEvent = {
+    sessionId: string;
+    sessionKey?: string;
+    messageCount: number;
+    durationMs?: number;
+    reason?: string;
+    sessionFile?: string;
+  };
+
+  export type OpenClawPluginApi = {
+    id: string;
+    name: string;
+    runtime: PluginRuntime;
+    logger: PluginLogger;
+    pluginConfig?: Record<string, unknown>;
+    registerTool: (tool: {
+      name: string;
+      description: string;
+      parameters: Record<string, unknown>;
+      optional?: boolean;
+      execute: (id: string, params: Record<string, unknown>) => Promise<{
+        content: { type: string; text: string }[];
+      }>;
+    }) => void;
+    on: {
+      (
+        hookName: "before_agent_start",
+        handler: (
+          event: PluginHookBeforeAgentStartEvent,
+          ctx: PluginHookAgentContext,
+        ) =>
+          | Promise<PluginHookBeforeAgentStartResult | void>
+          | PluginHookBeforeAgentStartResult
+          | void,
+        opts?: { priority?: number },
+      ): void;
+      (
+        hookName: "before_compaction",
+        handler: (
+          event: PluginHookBeforeCompactionEvent,
+          ctx: PluginHookAgentContext,
+        ) => Promise<void> | void,
+        opts?: { priority?: number },
+      ): void;
+      (
+        hookName: "before_reset",
+        handler: (
+          event: PluginHookBeforeResetEvent,
+          ctx: PluginHookAgentContext,
+        ) => Promise<void> | void,
+        opts?: { priority?: number },
+      ): void;
+      (
+        hookName: "session_end",
+        handler: (
+          event: PluginHookSessionEndEvent,
+          ctx: PluginHookSessionContext,
+        ) => Promise<void> | void,
+        opts?: { priority?: number },
+      ): void;
+      (
+        hookName: PluginHookName,
+        handler: (event: unknown, ctx: unknown) => unknown,
+        opts?: { priority?: number },
+      ): void;
+    };
+  };
+
+  export type OpenClawPluginDefinition = {
+    id: string;
+    name: string;
+    description?: string;
+    version?: string;
+    register: (api: OpenClawPluginApi) => void | Promise<void>;
+  };
+
+  export function definePluginEntry(
+    def: OpenClawPluginDefinition,
+  ): OpenClawPluginDefinition;
+}
+
+declare module "openclaw/plugin-sdk/agent-runtime" {
+  export interface PreparedModel {
+    model: unknown;
+    auth: unknown;
+  }
+
+  export interface PreparedModelError {
+    error: string;
+  }
+
+  export function prepareSimpleCompletionModelForAgent(opts: {
+    cfg: unknown;
+    agentId: string;
+    modelRef?: string;
+  }): Promise<PreparedModel | PreparedModelError>;
+
+  export interface CompletionMessage {
+    role: string;
+    content: { type: string; text?: string }[];
+    timestamp: number;
+  }
+
+  export interface CompletionResult {
+    content: { type: string; text?: string }[];
+  }
+
+  export function completeWithPreparedSimpleCompletionModel(opts: {
+    model: unknown;
+    auth: unknown;
+    context: {
+      systemPrompt?: string;
+      messages: CompletionMessage[];
+    };
+    options?: { maxTokens?: number };
+  }): Promise<CompletionResult>;
+}

package/plugin/vendor/reflexio/reflexio/integrations/openclaw/vitest.config.ts

@@ -0,0 +1,13 @@
+import { defineConfig } from "vitest/config";
+
+export default defineConfig({
+  test: {
+    include: ["tests/**/*.test.ts"],
+    env: {
+      // Point HOME to a nonexistent path so tests cannot accidentally read
+      // ~/.reflexio/.env or other real user config files. Tests that need
+      // specific home-dir content must set HOME themselves.
+      HOME: "/nonexistent-test-home",
+    },
+  },
+});

package/plugin/vendor/reflexio/reflexio/integrations/openclaw-embedded/README.md

@@ -0,0 +1,120 @@
+# Reflexio OpenClaw-Embedded Plugin
+
+A lightweight Openclaw plugin that delivers Reflexio-style user profile and playbook capabilities entirely within Openclaw's native primitives — no Reflexio server required.
+
+## Table of Contents
+
+- [How It Works](#how-it-works)
+- [Prerequisites](#prerequisites)
+- [Installation](#installation)
+- [First-use Setup](#first-use-setup)
+- [Configuration](#configuration)
+- [Comparison with Other Reflexio Integrations](#comparison-with-other-reflexio-integrations)
+- [Uninstall](#uninstall)
+- [Further Reading](#further-reading)
+
+## How It Works
+
+The plugin captures two kinds of memory:
+
+- **Profiles** — durable user facts (diet, preferences, timezone, role). Stored as `.md` files under `.reflexio/profiles/` with a TTL.
+- **Playbooks** — procedural rules learned from corrections (user corrects → agent adjusts → user confirms → rule written). Stored under `.reflexio/playbooks/`.
+
+Three flows capture memory at different moments:
+
+- **Flow A (in-session profile)**: agent detects a preference/fact/config in the user message and writes immediately via the `reflexio_write_profile` tool.
+- **Flow B (in-session playbook)**: agent recognizes correction+confirmation multi-turn pattern and writes via `reflexio_write_playbook`.
+- **Flow C (session-end batch)**: hooks fire on `before_compaction`, `before_reset`, and `session_end`; spawn a `reflexio-extractor` sub-agent that extracts from the full transcript, runs dedup, and writes/deletes `.md` files.
+
+Consolidation runs on-demand via `reflexio_run_consolidation` tool or automatically via heartbeat check (`reflexio_consolidation_check`). It clusters similar files, asks the LLM to deduplicate/merge/resolve contradictions, and writes one-fact-per-file outputs.
+
+All retrieval is via Openclaw's memory engine — vector + FTS + MMR + temporal decay. When Active Memory is enabled, relevant profiles/playbooks are auto-injected into each turn.
+
+## Prerequisites
+
+- [OpenClaw](https://openclaw.ai) installed and `openclaw` CLI on PATH
+- Node.js (for the plugin runtime)
+- macOS or Linux (Windows via WSL)
+- A bash-compatible shell (install/uninstall scripts use `#!/usr/bin/env bash`)
+- Strongly recommended:
+  - An embedding provider API key (OpenAI, Gemini, Voyage, or Mistral) for vector search
+  - The `active-memory` plugin enabled (auto-retrieval into turns)
+
+The plugin works without active-memory and without an embedding key — with degraded retrieval quality. See `references/architecture.md` for degradation modes.
+
+## Installation
+
+```bash
+# From the plugin directory:
+./scripts/install.sh
+```
+
+What it does:
+1. Installs the `plugin/` directory as an Openclaw plugin (copied to `~/.openclaw/extensions/reflexio-embedded/`)
+2. Enables the `active-memory` plugin and configures agent targeting + `.reflexio/` extraPath
+3. Restarts the Openclaw gateway
+
+Skills are auto-served from the extension directory via the manifest. Agent definitions are injected via `extraSystemPrompt` at runtime. Heartbeat entry is appended to `HEARTBEAT.md` on first agent session by `setup.ts`.
+
+## First-use Setup
+
+The first time an agent invokes the `reflexio-embedded` skill, it runs a one-time bootstrap:
+
+1. Probes current config via `openclaw config get` + `openclaw memory status --deep`.
+2. For any missing prereq, asks the user for approval before running `openclaw config set`.
+3. On success, creates `.reflexio/.setup_complete_<agentId>` marker — subsequent sessions skip.
+
+This guarantees zero manual `openclaw.json` editing. If exec is denied by admin policy, the skill prints the exact commands for the user to run manually.
+
+## Configuration
+
+Defaults are defined in `openclaw.plugin.json` via `configSchema`. To override, add to your `openclaw.json`:
+
+```json
+{
+  "plugins": {
+    "entries": {
+      "reflexio-embedded": {
+        "config": {
+          "dedup": { "shallow_threshold": 0.4, "top_k": 5 },
+          "consolidation": { "threshold_hours": 24 }
+        }
+      }
+    }
+  }
+}
+```
+
+Tunables:
+
+| Knob | Default | What it controls |
+|---|---|---|
+| `dedup.shallow_threshold` | 0.4 | Similarity above which in-session writes trigger dedup |
+| `dedup.full_threshold` | 0.75 | Similarity cluster-member cutoff in consolidation |
+| `dedup.top_k` | 5 | How many neighbors to consider |
+| `ttl_sweep.on_bootstrap` | `true` | Whether to sweep expired profiles on each agent turn |
+| `consolidation.threshold_hours` | 24 | Heartbeat consolidation interval |
+| `extraction.subagent_timeout_seconds` | 120 | Flow C sub-agent timeout |
+
+## Comparison with Other Reflexio Integrations
+
+See `references/comparison.md` for a full matrix.
+
+- **`integrations/openclaw-embedded/`** (this plugin): self-contained; no Reflexio server; single-user.
+- **`integrations/openclaw/`** (federated): requires running Reflexio server; multi-user; cross-instance aggregation.
+
+Both can coexist in the same Openclaw instance, but installing both serves no purpose — pick one.
+
+## Uninstall
+
+```bash
+./scripts/uninstall.sh           # preserves .reflexio/ user data
+./scripts/uninstall.sh --purge   # also deletes .reflexio/ user data
+```
+
+## Further Reading
+
+- [Architecture deep-dive](references/architecture.md)
+- [Prompt porting notes](references/porting-notes.md)
+- [Future work / v2 deferrals](references/future-work.md)
+- [Manual testing guide](TESTING.md)

package/plugin/vendor/reflexio/reflexio/integrations/openclaw-embedded/TESTING.md

@@ -0,0 +1,168 @@
+# Manual Testing Guide
+
+End-to-end manual validation of `openclaw-embedded`. Run this before each release.
+
+## Prerequisites
+
+- A clean Openclaw instance (fresh workspace, or separate test workspace)
+- Node and openclaw CLI on PATH
+- An embedding provider configured (optional but recommended for full coverage)
+
+## 1. Unit tests
+
+From the `openclaw-embedded/` directory:
+
+```bash
+npm test
+```
+
+Expected: 54 tests pass. If any fail, stop — fix before proceeding.
+
+## 2. Hook smoke test
+
+```bash
+node plugin/hook/smoke-test.js
+```
+
+Expected: all PASS lines printed, no FAIL.
+
+## 3. Install plugin
+
+```bash
+./scripts/install.sh
+```
+
+Expected verification output:
+```text
+  ✓ plugin registered and loaded
+```
+
+If any ⚠ warnings, investigate before moving on.
+
+## 4. First-use bootstrap
+
+- Open a new Openclaw agent session.
+- Say: "test the reflexio-embedded skill setup".
+- Expected: the agent invokes the skill, runs probing commands, asks for approval to configure active-memory and extraPath.
+- Approve each step.
+- Verify `.reflexio/.setup_complete_<agentId>` marker exists.
+
+## 5. Flow A — profile capture
+
+In the agent session:
+
+- Say: "By the way, I'm vegetarian."
+- Expected: agent writes `.reflexio/profiles/diet-vegetarian-<nanoid>.md` with:
+  - Frontmatter: `type: profile`, `id: prof_*`, `ttl: infinity`, `expires: never`
+  - Body: ~1-sentence description
+
+```bash
+cat .reflexio/profiles/diet-*.md
+```
+
+Verify the file matches expectations.
+
+## 6. Flow B — playbook capture
+
+- Say: "Write a commit message for 'fix auth bug'."
+- Expected: agent writes a commit message.
+- Say: "No, don't add trailers."
+- Expected: agent rewrites without trailers.
+- Say: "Perfect, commit it."
+- Expected: agent writes `.reflexio/playbooks/commit-no-trailers-<nanoid>.md`.
+
+```bash
+cat .reflexio/playbooks/commit-*.md
+```
+
+Verify frontmatter + `## When` / `## What` / `## Why` sections.
+
+## 7. Flow C — batch extraction at session boundary
+
+- Have a longer conversation (5+ turns) covering facts and corrections.
+- The `before_compaction`, `before_reset`, or `session_end` hook fires automatically.
+- Expected: a `reflexio-extractor` sub-agent is spawned.
+
+Check `.reflexio/profiles/` and `.reflexio/playbooks/` — new files should have appeared corresponding to any facts/corrections the agent missed in-session.
+
+## 8. Retrieval validation
+
+Start a new session. Ask: "What do you know about my diet?"
+
+- With Active Memory enabled: expected answer references "vegetarian" from the captured profile.
+- With Active Memory disabled: expected agent calls `reflexio_search` tool, then answers.
+
+## 9. Consolidation (on-demand)
+
+After accumulating 10+ entries across sessions, run:
+
+```text
+/skill reflexio-consolidate
+```
+
+Expected:
+- Agent calls `reflexio_run_consolidation` tool.
+- Returns "Consolidation started in background."
+- Logs show clustering, LLM judgment, and file write/delete activity.
+
+Check `.reflexio/` before and after — duplicate or overlapping entries should be consolidated into individual fact files.
+
+## 10. TTL sweep
+
+- Create a profile with short TTL:
+  ```text
+  Call the `reflexio_write_profile` tool with: slug="test-temp", ttl="one_day", body="temp fact"
+  ```
+- Manually edit its `expires` to a past date:
+  ```bash
+  # Edit .reflexio/profiles/test-temp-*.md — set expires: 2020-01-01
+  ```
+- Start a new agent turn (triggers `before_prompt_build` hook with TTL sweep).
+- Expected: the expired profile is deleted.
+
+## 11. Degradation: no Active Memory
+
+- Disable active-memory: `openclaw plugins disable active-memory`
+- Restart gateway.
+- Start new session, ask a question whose answer needs a captured profile.
+- Expected: agent calls `reflexio_search` tool explicitly (per SKILL.md fallback), then answers.
+- Re-enable: `openclaw plugins enable active-memory`.
+
+## 12. Degradation: no embedding provider
+
+- Unset embedding env vars.
+- Restart gateway.
+- Ask the agent something whose answer needs retrieval.
+- Expected: retrieval works via FTS only (quality lower but functional).
+
+## 13. Uninstall
+
+```bash
+./scripts/uninstall.sh
+```
+
+Verify:
+- `openclaw plugins inspect reflexio-embedded` shows not loaded.
+- `~/.openclaw/extensions/reflexio-embedded/` does not exist.
+- `.reflexio/` in the workspace is preserved.
+
+Run `./scripts/uninstall.sh --purge` in a test workspace to verify `.reflexio/` is deleted.
+
+## Test report template
+
+When testing for a release:
+
+```text
+Tested: <date> <tester>
+Openclaw version: <version>
+Unit tests: <pass/fail>
+Hook smoke test: <pass/fail>
+Flow A: <pass/fail — notes>
+Flow B: <pass/fail — notes>
+Flow C: <pass/fail — notes>
+Retrieval: <pass/fail — notes>
+Consolidation: <pass/fail — notes>
+TTL sweep: <pass/fail — notes>
+Degradation modes: <pass/fail — notes>
+Uninstall: <pass/fail — notes>
+```