claude-smart 0.2.41 → 0.2.43

package/plugin/vendor/reflexio/reflexio/integrations/openclaw-embedded/plugin/lib/io.ts

@@ -0,0 +1,155 @@
+import * as crypto from "node:crypto";
+import * as fs from "node:fs";
+import * as path from "node:path";
+
+const SLUG_REGEX = /^[a-z0-9][a-z0-9-]{0,47}$/;
+const VALID_TTLS = [
+  "one_day",
+  "one_week",
+  "one_month",
+  "one_quarter",
+  "one_year",
+  "infinity",
+] as const;
+export type Ttl = (typeof VALID_TTLS)[number];
+
+export function generateNanoid(): string {
+  const bytes = crypto.randomBytes(3);
+  return Array.from(bytes)
+    .map((b) => (b % 36).toString(36))
+    .join("")
+    .slice(0, 4)
+    .padEnd(4, "0");
+}
+
+export function validateSlug(slug: string): void {
+  if (!slug || !SLUG_REGEX.test(slug)) {
+    throw new Error(`Invalid slug: "${slug}". Must match ${SLUG_REGEX}`);
+  }
+}
+
+export function validateTtl(ttl: string): asserts ttl is Ttl {
+  if (!VALID_TTLS.includes(ttl as Ttl)) {
+    throw new Error(
+      `Invalid TTL: "${ttl}". Must be one of: ${VALID_TTLS.join(", ")}`
+    );
+  }
+}
+
+export function computeExpires(ttl: Ttl, created: string): string {
+  if (ttl === "infinity") return "never";
+  const date = new Date(created);
+  const offsets: Record<string, () => void> = {
+    one_day: () => date.setUTCDate(date.getUTCDate() + 1),
+    one_week: () => date.setUTCDate(date.getUTCDate() + 7),
+    one_month: () => date.setUTCMonth(date.getUTCMonth() + 1),
+    one_quarter: () => date.setUTCMonth(date.getUTCMonth() + 3),
+    one_year: () => date.setUTCFullYear(date.getUTCFullYear() + 1),
+  };
+  offsets[ttl]();
+  return date.toISOString().slice(0, 10);
+}
+
+export function resolveWorkspace(): string {
+  return process.env.WORKSPACE || process.cwd();
+}
+
+interface WriteProfileOpts {
+  slug: string;
+  ttl: Ttl;
+  body: string;
+  supersedes?: string[];
+  workspace?: string;
+}
+
+export function writeProfileFile(opts: WriteProfileOpts): string {
+  validateSlug(opts.slug);
+  validateTtl(opts.ttl);
+
+  const suffix = generateNanoid();
+  const id = `prof_${suffix}`;
+  const created = new Date().toISOString().replace(/\.\d+Z$/, "Z");
+  const expires = computeExpires(opts.ttl, created);
+
+  const ws = opts.workspace || resolveWorkspace();
+  const dir = path.join(ws, ".reflexio", "profiles");
+  fs.mkdirSync(dir, { recursive: true });
+
+  const filePath = path.join(dir, `${opts.slug}-${suffix}.md`);
+  const tmpPath = `${filePath}.tmp.${process.pid}`;
+
+  const lines = [
+    "---",
+    "type: profile",
+    `id: ${id}`,
+    `created: ${created}`,
+    `ttl: ${opts.ttl}`,
+    `expires: ${expires}`,
+  ];
+  if (opts.supersedes && opts.supersedes.length > 0) {
+    lines.push(`supersedes: [${opts.supersedes.join(", ")}]`);
+  }
+  lines.push("---", "", opts.body, "");
+
+  try {
+    fs.writeFileSync(tmpPath, lines.join("\n"));
+    fs.renameSync(tmpPath, filePath);
+  } catch (err) {
+    try { fs.unlinkSync(tmpPath); } catch {}
+    throw err;
+  }
+
+  return filePath;
+}
+
+interface WritePlaybookOpts {
+  slug: string;
+  body: string;
+  supersedes?: string[];
+  workspace?: string;
+}
+
+export function writePlaybookFile(opts: WritePlaybookOpts): string {
+  validateSlug(opts.slug);
+
+  const suffix = generateNanoid();
+  const id = `pbk_${suffix}`;
+  const created = new Date().toISOString().replace(/\.\d+Z$/, "Z");
+
+  const ws = opts.workspace || resolveWorkspace();
+  const dir = path.join(ws, ".reflexio", "playbooks");
+  fs.mkdirSync(dir, { recursive: true });
+
+  const filePath = path.join(dir, `${opts.slug}-${suffix}.md`);
+  const tmpPath = `${filePath}.tmp.${process.pid}`;
+
+  const lines = [
+    "---",
+    "type: playbook",
+    `id: ${id}`,
+    `created: ${created}`,
+  ];
+  if (opts.supersedes && opts.supersedes.length > 0) {
+    lines.push(`supersedes: [${opts.supersedes.join(", ")}]`);
+  }
+  lines.push("---", "", opts.body, "");
+
+  try {
+    fs.writeFileSync(tmpPath, lines.join("\n"));
+    fs.renameSync(tmpPath, filePath);
+  } catch (err) {
+    try { fs.unlinkSync(tmpPath); } catch {}
+    throw err;
+  }
+
+  return filePath;
+}
+
+export function deleteFile(filePath: string): void {
+  try {
+    fs.unlinkSync(filePath);
+  } catch (err: any) {
+    if (err.code !== "ENOENT") throw err;
+    console.error(`[reflexio] warning: file already gone: ${filePath}`);
+  }
+}

package/plugin/vendor/reflexio/reflexio/integrations/openclaw-embedded/plugin/lib/openclaw-cli.ts

@@ -0,0 +1,67 @@
+/**
+ * Abstraction over command execution.
+ * Plugin runtime injects api.runtime.system.runCommandWithTimeout.
+ * Tests inject a mock.
+ */
+export type CommandRunner = (
+  argv: string[],
+  opts: { timeoutMs: number; input?: string }
+) => Promise<{ stdout: string; stderr: string; code: number | null }>;
+
+export interface MemorySearchResult {
+  path: string;
+  startLine: number;
+  endLine: number;
+  score: number;
+  snippet: string;
+  source: string;
+}
+
+export interface MemorySearchResponse {
+  results: MemorySearchResult[];
+}
+
+/**
+ * Call `openclaw memory search` via the injected runner.
+ * Returns empty array on any failure (graceful degradation).
+ */
+export async function memorySearch(
+  query: string,
+  maxResults: number,
+  runner: CommandRunner
+): Promise<MemorySearchResult[]> {
+  try {
+    const result = await runner(
+      ["openclaw", "memory", "search", query, "--json", "--max-results", String(maxResults)],
+      { timeoutMs: 30_000 }
+    );
+    const parsed: MemorySearchResponse = JSON.parse(result.stdout.trim());
+    return parsed.results || [];
+  } catch (err) {
+    console.error(`[reflexio] openclaw memory search failed: ${err}`);
+    return [];
+  }
+}
+
+/**
+ * Call `openclaw memory index --force` to rebuild the search index.
+ * Necessary after bulk file deletions (e.g. consolidation) so that
+ * deleted files are dropped from search results.
+ */
+export async function reindexMemory(runner: CommandRunner): Promise<void> {
+  try {
+    await runner(
+      ["openclaw", "memory", "index", "--force"],
+      { timeoutMs: 60_000 }
+    );
+  } catch (err) {
+    console.error(`[reflexio] openclaw memory index --force failed: ${err}`);
+  }
+}
+
+/**
+ * Abstraction over LLM inference.
+ * Plugin runtime creates this from the SDK simple completion API.
+ * Tests inject a mock.
+ */
+export type InferFn = (prompt: string) => Promise<string | null>;

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

@@ -0,0 +1,33 @@
+import { memorySearch, type MemorySearchResult, type CommandRunner, type InferFn } from "./openclaw-cli.ts";
+import { preprocessQuery } from "./dedup.ts";
+
+/**
+ * Search memory with a query string, optionally filtering by type.
+ */
+export async function rawSearch(
+  query: string,
+  maxResults: number,
+  type: "profile" | "playbook" | undefined,
+  runner: CommandRunner
+): Promise<MemorySearchResult[]> {
+  let results = await memorySearch(query, maxResults, runner);
+  if (type) {
+    const typeDir = type === "profile" ? "/profiles/" : "/playbooks/";
+    results = results.filter((r) => r.path.includes(typeDir));
+  }
+  return results;
+}
+
+/**
+ * Preprocess query (via LLM rewrite) then search memory.
+ */
+export async function search(
+  rawQuery: string,
+  maxResults: number,
+  type: "profile" | "playbook" | undefined,
+  runner: CommandRunner,
+  inferFn: InferFn
+): Promise<MemorySearchResult[]> {
+  const query = await preprocessQuery(rawQuery, inferFn);
+  return rawSearch(query, maxResults, type, runner);
+}

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

@@ -0,0 +1,76 @@
+import { writePlaybookFile, deleteFile, validateSlug } from "./io.ts";
+import { preprocessQuery, judgeDedup, extractId } from "./dedup.ts";
+import { rawSearch } from "./search.ts";
+import type { CommandRunner, InferFn } from "./openclaw-cli.ts";
+
+export interface WritePlaybookConfig {
+  shallow_threshold: number;
+  top_k: number;
+}
+
+export interface WritePlaybookOpts {
+  slug: string;
+  body: string;
+  workspace?: string;
+  config: WritePlaybookConfig;
+  runner: CommandRunner;
+  inferFn: InferFn;
+}
+
+/**
+ * Full playbook write orchestration:
+ * validate → preprocess → search → judge → write → delete (if merging)
+ */
+export async function writePlaybook(opts: WritePlaybookOpts): Promise<string> {
+  console.info(`[reflexio] writePlaybook: slug=${opts.slug} bodyLen=${opts.body.length} workspace=${opts.workspace ?? "(default)"}`);
+
+  validateSlug(opts.slug);
+
+  const query = await preprocessQuery(opts.body, opts.inferFn);
+  console.info(`[reflexio] writePlaybook: preprocessed query="${query.slice(0, 120)}"`);
+
+  const neighbors = await rawSearch(query, opts.config.top_k, "playbook", opts.runner);
+  console.info(`[reflexio] writePlaybook: found ${neighbors.length} neighbor(s)${neighbors[0] ? `, top score=${neighbors[0].score.toFixed(3)} path=${neighbors[0].path}` : ""}`);
+
+  const top = neighbors[0];
+  let bodyToWrite = opts.body;
+  let supersedes: string[] | undefined;
+  let deleteTarget: string | undefined;
+
+  if (top) {
+    const bodyFromSnippet = top.snippet.split("---").slice(2).join("---").trim();
+    const result = await judgeDedup(opts.body, bodyFromSnippet, opts.inferFn);
+    console.info(`[reflexio] writePlaybook: dedup decision="${result.decision}"`);
+
+    if (result.decision === "merge_and_resolve") {
+      bodyToWrite = result.resolved;
+      const oldId = extractId(top.snippet);
+      if (oldId) {
+        supersedes = [oldId];
+        deleteTarget = top.path;
+        console.info(`[reflexio] writePlaybook: merge_and_resolve id=${oldId} path=${top.path} resolvedLen=${result.resolved.length}`);
+      } else {
+        console.error(`[reflexio] writePlaybook: merge_and_resolve but could not extract id from snippet`);
+      }
+    }
+  }
+
+  const newPath = writePlaybookFile({
+    slug: opts.slug,
+    body: bodyToWrite,
+    supersedes,
+    workspace: opts.workspace,
+  });
+  console.info(`[reflexio] writePlaybook: wrote ${newPath}${supersedes ? ` (supersedes: ${supersedes.join(", ")})` : ""}`);
+
+  if (deleteTarget) {
+    const ws = opts.workspace || process.env.WORKSPACE || process.cwd();
+    const absDelete = deleteTarget.startsWith("/")
+      ? deleteTarget
+      : `${ws}/${deleteTarget}`;
+    deleteFile(absDelete);
+    console.info(`[reflexio] writePlaybook: deleted old file ${absDelete}`);
+  }
+
+  return newPath;
+}

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

@@ -0,0 +1,79 @@
+import { writeProfileFile, deleteFile, validateSlug, validateTtl, type Ttl } from "./io.ts";
+import { preprocessQuery, judgeDedup, extractId } from "./dedup.ts";
+import { rawSearch } from "./search.ts";
+import type { CommandRunner, InferFn } from "./openclaw-cli.ts";
+
+export interface WriteProfileConfig {
+  shallow_threshold: number;
+  top_k: number;
+}
+
+export interface WriteProfileOpts {
+  slug: string;
+  ttl: Ttl | string;
+  body: string;
+  workspace?: string;
+  config: WriteProfileConfig;
+  runner: CommandRunner;
+  inferFn: InferFn;
+}
+
+/**
+ * Full profile write orchestration:
+ * validate → preprocess → search → judge → write → delete (if merging)
+ */
+export async function writeProfile(opts: WriteProfileOpts): Promise<string> {
+  console.info(`[reflexio] writeProfile: slug=${opts.slug} ttl=${opts.ttl} bodyLen=${opts.body.length} workspace=${opts.workspace ?? "(default)"}`);
+
+  validateSlug(opts.slug);
+  validateTtl(opts.ttl);
+
+  const query = await preprocessQuery(opts.body, opts.inferFn);
+  console.info(`[reflexio] writeProfile: preprocessed query="${query.slice(0, 120)}"`);
+
+  const neighbors = await rawSearch(query, opts.config.top_k, "profile", opts.runner);
+  console.info(`[reflexio] writeProfile: found ${neighbors.length} neighbor(s)${neighbors[0] ? `, top score=${neighbors[0].score.toFixed(3)} path=${neighbors[0].path}` : ""}`);
+
+  const top = neighbors[0];
+  let bodyToWrite = opts.body;
+  let supersedes: string[] | undefined;
+  let deleteTarget: string | undefined;
+
+  if (top) {
+    const bodyFromSnippet = top.snippet.split("---").slice(2).join("---").trim();
+    const result = await judgeDedup(opts.body, bodyFromSnippet, opts.inferFn);
+    console.info(`[reflexio] writeProfile: dedup decision="${result.decision}"`);
+
+    if (result.decision === "merge_and_resolve") {
+      bodyToWrite = result.resolved;
+      const oldId = extractId(top.snippet);
+      if (oldId) {
+        supersedes = [oldId];
+        deleteTarget = top.path;
+        console.info(`[reflexio] writeProfile: merge_and_resolve id=${oldId} path=${top.path} resolvedLen=${result.resolved.length}`);
+      } else {
+        console.error(`[reflexio] writeProfile: merge_and_resolve but could not extract id from snippet`);
+      }
+    }
+  }
+
+  const newPath = writeProfileFile({
+    slug: opts.slug,
+    ttl: opts.ttl as Ttl,
+    body: bodyToWrite,
+    supersedes,
+    workspace: opts.workspace,
+  });
+  console.info(`[reflexio] writeProfile: wrote ${newPath}${supersedes ? ` (supersedes: ${supersedes.join(", ")})` : ""}`);
+
+  if (deleteTarget) {
+    const ws = opts.workspace || process.env.WORKSPACE || process.cwd();
+    const absDelete = deleteTarget.startsWith("/")
+      ? deleteTarget
+      : `${ws}/${deleteTarget}`;
+    deleteFile(absDelete);
+    console.info(`[reflexio] writeProfile: deleted old file ${absDelete}`);
+  }
+
+  return newPath;
+}

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

@@ -0,0 +1,46 @@
+{
+  "id": "reflexio-embedded",
+  "name": "Reflexio Embedded",
+  "description": "Reflexio-style user profile and playbook extraction using Openclaw's native memory engine, hooks, and sub-agents — no Reflexio server required.",
+  "skills": ["./skills"],
+  "configSchema": {
+    "type": "object",
+    "additionalProperties": false,
+    "properties": {
+      "dedup": {
+        "type": "object",
+        "additionalProperties": false,
+        "properties": {
+          "shallow_threshold": { "type": "number", "default": 0.4 },
+          "full_threshold": { "type": "number", "default": 0.75 },
+          "top_k": { "type": "integer", "default": 5 }
+        },
+        "default": { "shallow_threshold": 0.4, "full_threshold": 0.75, "top_k": 5 }
+      },
+      "ttl_sweep": {
+        "type": "object",
+        "additionalProperties": false,
+        "properties": {
+          "on_bootstrap": { "type": "boolean", "default": true }
+        },
+        "default": { "on_bootstrap": true }
+      },
+      "consolidation": {
+        "type": "object",
+        "additionalProperties": false,
+        "properties": {
+          "threshold_hours": { "type": "integer", "default": 24 }
+        },
+        "default": { "threshold_hours": 24 }
+      },
+      "extraction": {
+        "type": "object",
+        "additionalProperties": false,
+        "properties": {
+          "subagent_timeout_seconds": { "type": "integer", "default": 120 }
+        },
+        "default": { "subagent_timeout_seconds": 120 }
+      }
+    }
+  }
+}

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

@@ -0,0 +1,18 @@
+{
+  "name": "@reflexioai/reflexio",
+  "version": "0.1.0",
+  "description": "A lightweight Openclaw plugin that delivers agent self-improving capabilities",
+  "private": true,
+  "type": "module",
+  "openclaw": {
+    "extensions": ["./index.ts"],
+    "compat": {
+      "pluginApi": ">=2026.3.24",
+      "minGatewayVersion": "2026.3.24"
+    },
+    "build": {
+      "openclawVersion": "2026.4.14",
+      "pluginSdkVersion": "2026.4.14"
+    }
+  }
+}

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

@@ -0,0 +1,36 @@
+# Openclaw-Embedded Prompts
+
+LLM prompt templates used by Flow C sub-agents and consolidation.
+
+## Files
+
+- `profile_extraction.md` — extract durable user facts from a transcript
+- `playbook_extraction.md` — extract procedural rules from correction+confirmation patterns
+- `full_consolidation.md` — consolidate a cluster of similar items into individual facts
+
+## Format
+
+Each file is a `.prompt.md` with YAML frontmatter (matches Reflexio's
+`server/prompt/prompt_bank/` convention). Unlike upstream's versioned layout
+(`<name>/v<ver>.prompt.md`), we store prompts flat (`<name>.md`) since the
+plugin ships atomically with one active version at a time.
+
+```yaml
+---
+active: true
+description: "one-line description"
+changelog: "what changed in this version"
+variables:
+  - var1
+  - var2
+---
+
+prompt body, with {var1} and {var2} substitution points
+```
+
+## Upstream sync
+
+`profile_extraction.md` and `playbook_extraction.md` are ports of Reflexio's
+prompt_bank entries. On upstream bumps, review the prompt diff against our
+adapted versions. Porting notes will be maintained in
+`../references/porting-notes.md` (added in a later phase).

package/plugin/vendor/reflexio/reflexio/integrations/openclaw-embedded/plugin/prompts/full_consolidation.md

@@ -0,0 +1,56 @@
+---
+active: true
+description: "N-way cluster consolidation — produces one-fact-per-file output"
+changelog: "v2 (2026-04-21): one-fact-per-file output; v1 (2026-04-16): initial single-merged-entry design"
+variables:
+  - cluster
+---
+
+You consolidate a cluster of 2-10 similar items (profiles or playbooks) that have accumulated over time.
+
+## Core principle
+
+**One fact per file.** Each output entry must contain exactly ONE atomic fact or preference (1-2 sentences). Do NOT combine unrelated facts into a single entry.
+
+## Inputs
+
+A cluster of items, each with: `id`, `path`, `content`. All items are the same type (all profiles OR all playbooks).
+
+## Decision
+
+- `keep_all` — the cluster items are already distinct single-fact entries with no redundancy. **Prefer this when items cover different topics.**
+- `consolidate` — deduplicate, resolve contradictions, and split into individual facts.
+
+If the cluster is already well-separated (each item covers a distinct topic with no overlap), return `keep_all` immediately.
+
+### Contradiction handling
+
+If items contradict on the same topic, keep the most recent version. Explain in `rationale`.
+
+### Deduplication
+
+If multiple items say the same thing in different words, keep one canonical version.
+
+## Output schema
+
+```json
+{
+  "action": "keep_all | consolidate",
+  "facts": [
+    {
+      "slug": "kebab-case-topic",
+      "body": "Single atomic fact, 1-2 sentences.",
+      "source_ids": ["ids of items this fact was derived from"]
+    }
+  ],
+  "ids_to_delete": ["ids of all original items that are being replaced"],
+  "rationale": "2-3 sentences justifying the action"
+}
+```
+
+For `keep_all`: `facts` is empty, `ids_to_delete` is empty.
+For `consolidate`: `facts` contains one entry per distinct fact. `ids_to_delete` contains all original cluster IDs being replaced. Every original ID must appear in either `source_ids` of a fact or be explained in `rationale` as removed (contradiction/duplicate).
+
+## Cluster
+
+{cluster}