claude-smart 0.2.41 → 0.2.43

package/plugin/vendor/reflexio/reflexio/integrations/openclaw-embedded/tests/search.test.ts

@@ -0,0 +1,66 @@
+import { describe, it, expect } from "vitest";
+
+import { rawSearch, search } from "../plugin/lib/search.ts";
+import type { CommandRunner, MemorySearchResult, InferFn } from "../plugin/lib/openclaw-cli.ts";
+
+function createMockRunner(searchResults: MemorySearchResult[]): CommandRunner {
+  return async (argv) => {
+    if (argv.includes("memory") && argv.includes("search")) {
+      return {
+        stdout: JSON.stringify({ results: searchResults }),
+        stderr: "",
+        code: 0,
+      };
+    }
+    return { stdout: "", stderr: "unexpected command", code: 1 };
+  };
+}
+
+function createMockInferFn(result: string | null): InferFn {
+  return async () => result;
+}
+
+describe("rawSearch", () => {
+  it("calls memorySearch with query and returns results", async () => {
+    const items: MemorySearchResult[] = [
+      { path: ".reflexio/profiles/diet.md", score: 0.5, snippet: "vegan", startLine: 1, endLine: 5, source: "memory" },
+    ];
+    const runner = createMockRunner(items);
+    const results = await rawSearch("vegan diet", 3, undefined, runner);
+    expect(results).toHaveLength(1);
+    expect(results[0].path).toBe(".reflexio/profiles/diet.md");
+  });
+
+  it("filters results to specified type", async () => {
+    const items: MemorySearchResult[] = [
+      { path: ".reflexio/profiles/diet.md", score: 0.5, snippet: "x", startLine: 1, endLine: 5, source: "memory" },
+      { path: ".reflexio/playbooks/commit.md", score: 0.4, snippet: "y", startLine: 1, endLine: 5, source: "memory" },
+    ];
+    const runner = createMockRunner(items);
+    const results = await rawSearch("query", 5, "profile", runner);
+    expect(results).toHaveLength(1);
+    expect(results[0].path).toContain("profiles");
+  });
+
+  it("returns empty on memorySearch failure", async () => {
+    const runner = createMockRunner([]);
+    const results = await rawSearch("anything", 5, undefined, runner);
+    expect(results).toEqual([]);
+  });
+});
+
+describe("search", () => {
+  it("preprocesses query before searching", async () => {
+    const runner = createMockRunner([]);
+    const inferFn = createMockInferFn("Rewritten query about diet");
+    const results = await search("Oh sorry I like vegan food", 5, undefined, runner, inferFn);
+    expect(results).toEqual([]);
+  });
+
+  it("falls back to raw query if preprocessing fails", async () => {
+    const runner = createMockRunner([]);
+    const inferFn = createMockInferFn(null);
+    const results = await search("raw query here", 5, undefined, runner, inferFn);
+    expect(results).toEqual([]);
+  });
+});

package/plugin/vendor/reflexio/reflexio/integrations/openclaw-embedded/tests/smoke-test.ts

@@ -0,0 +1,140 @@
+// Standalone smoke test for the Reflexio Embedded hook handler.
+//
+// Run (requires tsx or ts-node in PATH):
+//   npx tsx tests/smoke-test.ts
+//
+// The plugin itself does NOT depend on tsx at runtime — Openclaw loads the
+// .ts files via its own bundled jiti runtime. This smoke test only needs tsx
+// because it runs outside Openclaw.
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+
+import {
+  injectBootstrapReminder,
+  spawnExtractor,
+  ttlSweepProfiles,
+} from "../plugin/hook/handler.ts";
+
+type FakeRunCall = {
+  sessionKey: string;
+  message: string;
+};
+
+async function main(): Promise<void> {
+  const workspace = fs.mkdtempSync(path.join(os.tmpdir(), "rfx-test-"));
+  fs.mkdirSync(path.join(workspace, ".reflexio", "profiles"), {
+    recursive: true,
+  });
+
+  // Create an expired profile
+  fs.writeFileSync(
+    path.join(workspace, ".reflexio", "profiles", "old-xxxx.md"),
+    `---
+type: profile
+id: prof_xxxx
+created: 2020-01-01T00:00:00Z
+ttl: one_day
+expires: 2020-01-02
+---
+
+Old expired fact.
+`,
+  );
+
+  // Create a fresh profile
+  fs.writeFileSync(
+    path.join(workspace, ".reflexio", "profiles", "fresh-yyyy.md"),
+    `---
+type: profile
+id: prof_yyyy
+created: 2026-04-16T00:00:00Z
+ttl: infinity
+expires: never
+---
+
+Fresh fact.
+`,
+  );
+
+  // 1. TTL sweep deletes the expired file, preserves the fresh one
+  await ttlSweepProfiles(workspace);
+  const oldExists = fs.existsSync(
+    path.join(workspace, ".reflexio", "profiles", "old-xxxx.md"),
+  );
+  const freshExists = fs.existsSync(
+    path.join(workspace, ".reflexio", "profiles", "fresh-yyyy.md"),
+  );
+  console.log(`Old file deleted: ${!oldExists ? "PASS" : "FAIL"}`);
+  console.log(`Fresh file preserved: ${freshExists ? "PASS" : "FAIL"}`);
+
+  // 2. Bootstrap reminder is non-empty and mentions SKILL.md
+  const reminder = injectBootstrapReminder();
+  console.log(
+    `Bootstrap reminder mentions SKILL.md: ${reminder.includes("SKILL.md") ? "PASS" : "FAIL"}`,
+  );
+
+  // 3. spawnExtractor forwards task + sessionKey to the runtime
+  const calls: FakeRunCall[] = [];
+  const runtime = {
+    subagent: {
+      run: async (params: FakeRunCall): Promise<{ runId: string }> => {
+        calls.push({
+          sessionKey: params.sessionKey,
+          message: params.message,
+        });
+        return { runId: "test-run" };
+      },
+    },
+  };
+  const runId = await spawnExtractor({
+    runtime,
+    workspaceDir: workspace,
+    sessionKey: "test-session",
+    messages: [
+      { role: "user", content: "I'm vegetarian" },
+      { role: "assistant", content: "Got it." },
+    ],
+    reason: "smoke-test",
+  });
+  console.log(
+    `Extractor spawned with runId: ${runId === "test-run" ? "PASS" : "FAIL"}`,
+  );
+  console.log(
+    `Extractor message contains transcript: ${
+      calls.length === 1 && calls[0].message.includes("vegetarian")
+        ? "PASS"
+        : "FAIL"
+    }`,
+  );
+
+  // 4. spawnExtractor skips when transcript is too short AND no sessionFile
+  const skipCalls: FakeRunCall[] = [];
+  const skipRuntime = {
+    subagent: {
+      run: async (params: FakeRunCall): Promise<{ runId: string }> => {
+        skipCalls.push(params);
+        return { runId: "unexpected" };
+      },
+    },
+  };
+  const skipRunId = await spawnExtractor({
+    runtime: skipRuntime,
+    workspaceDir: workspace,
+    sessionKey: "test-session-2",
+    messages: [],
+    reason: "smoke-test-skip",
+  });
+  console.log(
+    `Extractor skipped on empty transcript: ${
+      skipRunId === undefined && skipCalls.length === 0 ? "PASS" : "FAIL"
+    }`,
+  );
+
+  fs.rmSync(workspace, { recursive: true, force: true });
+}
+
+main().catch((err) => {
+  console.error(err);
+  process.exit(1);
+});

package/plugin/vendor/reflexio/reflexio/integrations/openclaw-embedded/tests/write-playbook.test.ts

@@ -0,0 +1,93 @@
+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 { writePlaybook } from "../plugin/lib/write-playbook.ts";
+import type { CommandRunner, MemorySearchResult, InferFn } from "../plugin/lib/openclaw-cli.ts";
+
+let inferCallCount: number;
+
+function createMockInferFn(results: (string | null)[]): InferFn {
+  inferCallCount = 0;
+  return async () => results[inferCallCount++] ?? null;
+}
+
+function createMockRunner(searchResults: MemorySearchResult[]): CommandRunner {
+  return async (argv) => {
+    if (argv.includes("memory") && argv.includes("search")) {
+      return {
+        stdout: JSON.stringify({ results: searchResults }),
+        stderr: "",
+        code: 0,
+      };
+    }
+    return { stdout: "", stderr: "unexpected command", code: 1 };
+  };
+}
+
+let workspace: string;
+
+beforeEach(() => {
+  workspace = fs.mkdtempSync(path.join(os.tmpdir(), "rfx-wpb-"));
+  fs.mkdirSync(path.join(workspace, ".reflexio", "playbooks"), { recursive: true });
+});
+
+afterEach(() => {
+  fs.rmSync(workspace, { recursive: true, force: true });
+});
+
+describe("writePlaybook", () => {
+  it("writes normally when no neighbors found", async () => {
+    const runner = createMockRunner([]);
+    const inferFn = createMockInferFn(["commit message query"]);
+
+    const result = await writePlaybook({
+      slug: "commit-no-trailers",
+      body: "## When\nCommit.\n\n## What\nNo trailers.\n\n## Why\nUser said.",
+      workspace, config: { shallow_threshold: 0.4, top_k: 5 },
+      runner, inferFn,
+    });
+
+    expect(fs.existsSync(result)).toBe(true);
+    const content = fs.readFileSync(result, "utf8");
+    expect(content).toContain("type: playbook");
+    expect(content).toContain("## When");
+  });
+
+  it("merge_and_resolve: writes resolved body and deletes old file", async () => {
+    const oldPath = path.join(workspace, ".reflexio", "playbooks", "old.md");
+    fs.writeFileSync(oldPath, "---\nid: pbk_old\n---\nOld playbook");
+
+    const runner = createMockRunner(
+      [{ path: oldPath, score: 0.5, snippet: "---\nid: pbk_old\n---\nOld playbook", startLine: 1, endLine: 5, source: "memory" }]
+    );
+    const inferFn = createMockInferFn([
+      "commit query",
+      '{"decision": "merge_and_resolve", "resolved": "## When\\nCommit.\\n\\n## What\\nUpdated rule."}',
+    ]);
+
+    const result = await writePlaybook({
+      slug: "commit-no-trailers",
+      body: "## When\nCommit.\n\n## What\nUpdated rule.",
+      workspace, config: { shallow_threshold: 0.4, top_k: 5 },
+      runner, inferFn,
+    });
+
+    expect(fs.existsSync(result)).toBe(true);
+    expect(fs.readFileSync(result, "utf8")).toContain("supersedes: [pbk_old]");
+    expect(fs.existsSync(oldPath)).toBe(false);
+  });
+
+  it("throws on invalid slug", async () => {
+    const runner = createMockRunner([]);
+    const inferFn = createMockInferFn([]);
+    await expect(
+      writePlaybook({
+        slug: "INVALID", body: "x",
+        workspace, config: { shallow_threshold: 0.4, top_k: 5 },
+        runner, inferFn,
+      })
+    ).rejects.toThrow("Invalid slug");
+  });
+});

package/plugin/vendor/reflexio/reflexio/integrations/openclaw-embedded/tests/write-profile.test.ts

@@ -0,0 +1,174 @@
+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 { writeProfile } from "../plugin/lib/write-profile.ts";
+import type { CommandRunner, MemorySearchResult, InferFn } from "../plugin/lib/openclaw-cli.ts";
+
+let inferCallCount: number;
+
+function createMockInferFn(results: (string | null)[]): InferFn {
+  inferCallCount = 0;
+  return async () => results[inferCallCount++] ?? null;
+}
+
+function createMockRunner(searchResults: MemorySearchResult[]): CommandRunner {
+  return async (argv) => {
+    if (argv.includes("memory") && argv.includes("search")) {
+      return {
+        stdout: JSON.stringify({ results: searchResults }),
+        stderr: "",
+        code: 0,
+      };
+    }
+    return { stdout: "", stderr: "unexpected command", code: 1 };
+  };
+}
+
+let workspace: string;
+
+beforeEach(() => {
+  workspace = fs.mkdtempSync(path.join(os.tmpdir(), "rfx-wp-"));
+  fs.mkdirSync(path.join(workspace, ".reflexio", "profiles"), { recursive: true });
+});
+
+afterEach(() => {
+  fs.rmSync(workspace, { recursive: true, force: true });
+});
+
+describe("writeProfile", () => {
+  it("writes normally when no neighbors found", async () => {
+    const runner = createMockRunner([]);
+    const inferFn = createMockInferFn(["diet vegan query"]);
+
+    const result = await writeProfile({
+      slug: "diet-vegan", ttl: "infinity",
+      body: "User is vegan.", workspace, config: { shallow_threshold: 0.4, top_k: 5 },
+      runner, inferFn,
+    });
+
+    expect(fs.existsSync(result)).toBe(true);
+    const content = fs.readFileSync(result, "utf8");
+    expect(content).toContain("User is vegan.");
+    expect(content).not.toContain("supersedes");
+  });
+
+  it("keeps both when LLM says keep_both", async () => {
+    const oldPath = path.join(workspace, ".reflexio", "profiles", "old.md");
+    fs.writeFileSync(oldPath, "---\nid: prof_old\n---\nDifferent fact");
+
+    const runner = createMockRunner(
+      [{ path: oldPath, score: 0.5, snippet: "---\nid: prof_old\n---\nDifferent fact", startLine: 1, endLine: 5, source: "memory" }]
+    );
+    const inferFn = createMockInferFn(["query", '{"decision": "keep_both"}']);
+
+    const result = await writeProfile({
+      slug: "new-fact", ttl: "infinity",
+      body: "New fact.", workspace, config: { shallow_threshold: 0.4, top_k: 5 },
+      runner, inferFn,
+    });
+
+    expect(fs.existsSync(result)).toBe(true);
+    expect(fs.existsSync(oldPath)).toBe(true);
+    expect(fs.readFileSync(result, "utf8")).not.toContain("supersedes");
+  });
+
+  it("merge_and_resolve: writes resolved body and deletes old file", async () => {
+    const oldPath = path.join(workspace, ".reflexio", "profiles", "old.md");
+    fs.writeFileSync(oldPath, "---\nid: prof_old\n---\nUser likes Greek food.");
+
+    const runner = createMockRunner(
+      [{ path: oldPath, score: 0.5, snippet: "---\nid: prof_old\n---\nUser likes Greek food.", startLine: 1, endLine: 5, source: "memory" }]
+    );
+    const inferFn = createMockInferFn([
+      "food preference query",
+      '{"decision": "merge_and_resolve", "resolved": "User does not like Greek food."}',
+    ]);
+
+    const result = await writeProfile({
+      slug: "food-preference", ttl: "infinity",
+      body: "User does not like Greek food.", workspace, config: { shallow_threshold: 0.4, top_k: 5 },
+      runner, inferFn,
+    });
+
+    expect(fs.existsSync(result)).toBe(true);
+    const content = fs.readFileSync(result, "utf8");
+    expect(content).toContain("User does not like Greek food.");
+    expect(content).toContain("supersedes: [prof_old]");
+    expect(fs.existsSync(oldPath)).toBe(false);
+  });
+
+  it("merge_and_resolve: preserves non-contradicted facts in resolved body", async () => {
+    const oldPath = path.join(workspace, ".reflexio", "profiles", "old.md");
+    fs.writeFileSync(oldPath, "---\nid: prof_old\n---\nUser likes Chinese food. User likes Greek food.");
+
+    const runner = createMockRunner(
+      [{ path: oldPath, score: 0.5, snippet: "---\nid: prof_old\n---\nUser likes Chinese food. User likes Greek food.", startLine: 1, endLine: 5, source: "memory" }]
+    );
+    const inferFn = createMockInferFn([
+      "food preference query",
+      '{"decision": "merge_and_resolve", "resolved": "User does not like Chinese food. User likes Greek food."}',
+    ]);
+
+    const result = await writeProfile({
+      slug: "food-preference", ttl: "infinity",
+      body: "User does not like Chinese food.", workspace, config: { shallow_threshold: 0.4, top_k: 5 },
+      runner, inferFn,
+    });
+
+    const content = fs.readFileSync(result, "utf8");
+    expect(content).toContain("User does not like Chinese food. User likes Greek food.");
+    expect(fs.existsSync(oldPath)).toBe(false);
+  });
+
+  it("still writes when infer fails at preprocessing", async () => {
+    const runner = createMockRunner([]);
+    const inferFn = createMockInferFn([null]);
+
+    const result = await writeProfile({
+      slug: "test", ttl: "infinity",
+      body: "Fact.", workspace, config: { shallow_threshold: 0.4, top_k: 5 },
+      runner, inferFn,
+    });
+
+    expect(fs.existsSync(result)).toBe(true);
+  });
+
+  it("still writes when openclaw memory search fails", async () => {
+    const runner = createMockRunner([]);
+    const inferFn = createMockInferFn(["query"]);
+
+    const result = await writeProfile({
+      slug: "test", ttl: "infinity",
+      body: "Fact.", workspace, config: { shallow_threshold: 0.4, top_k: 5 },
+      runner, inferFn,
+    });
+
+    expect(fs.existsSync(result)).toBe(true);
+  });
+
+  it("throws on invalid slug", async () => {
+    const runner = createMockRunner([]);
+    const inferFn = createMockInferFn([]);
+    await expect(
+      writeProfile({
+        slug: "INVALID", ttl: "infinity",
+        body: "x", workspace, config: { shallow_threshold: 0.4, top_k: 5 },
+        runner, inferFn,
+      })
+    ).rejects.toThrow("Invalid slug");
+  });
+
+  it("throws on invalid TTL", async () => {
+    const runner = createMockRunner([]);
+    const inferFn = createMockInferFn([]);
+    await expect(
+      writeProfile({
+        slug: "valid", ttl: "bad_ttl" as any,
+        body: "x", workspace, config: { shallow_threshold: 0.4, top_k: 5 },
+        runner, inferFn,
+      })
+    ).rejects.toThrow("Invalid TTL");
+  });
+});

package/plugin/vendor/reflexio/reflexio/integrations/openclaw-embedded/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"]
+}