#1 Persistent memory for AI coding agents based on real-world benchmarks
TypeScript agentmemoryagentsaiclaudeclaudecodecodexcopilotcursorgenaiharnesshermesmemoryompopenclawopencodepi
import type { IIIClient } from "iii-sdk";
const PRIVATE_TAG_RE = /<private>[\s\S]*?<\/private>/gi;
const SECRET_PATTERN_SOURCES = [
/(?:api[_-]?key|secret|token|password|credential|auth)[\s]*[=:]\s*["']?[A-Za-z0-9_\-/.+]{20,}["']?/gi,
/Bearer\s+[A-Za-z0-9._\-+/=]{20,}/gi,
/(?<![\p{L}\p{N}\p{M}_])sk-proj-[A-Za-z0-9\-_]{20,}/gu,
/(?<![\p{L}\p{N}\p{M}_])(?:sk|pk|rk|ak)-[A-Za-z0-9][A-Za-z0-9\-_]{19,}/gu,
/(?<![\p{L}\p{N}\p{M}_])sk-ant-[A-Za-z0-9\-_]{20,}/gu,
/gh[pus]_[A-Za-z0-9]{36,}/g,
/github_pat_[A-Za-z0-9_]{22,}/g,
/xoxb-[A-Za-z0-9\-]+/g,
/AKIA[0-9A-Z]{16}/g,
/AIza[A-Za-z0-9\-_]{35}/g,
/eyJ[A-Za-z0-9_-]{10,}\.[A-Za-z0-9_-]{10,}\.[A-Za-z0-9_-]{10,}/g,
/npm_[A-Za-z0-9]{36}/g,
/glpat-[A-Za-z0-9\-_]{20,}/g,
/dop_v1_[A-Za-z0-9]{64}/g,
];
const PRIVATE_KEY_BLOCK_RE =
/-----BEGIN [A-Z0-9 ]*PRIVATE KEY(?: BLOCK)?-----[\s\S]*?(?:-----END [A-Z0-9 ]*PRIVATE KEY(?: BLOCK)?-----|$)/g;
const URL_CREDENTIALS_RE =
/\b([a-z][a-z0-9+.-]*:\/\/)[^\s/?#@:"'<>]*:[^\s/?#@"'<>]+@/gi;
export function stripPrivateData(input: string): string {
let result = input.replace(PRIVATE_TAG_RE, "[REDACTED]");
result = result.replace(new RegExp(PRIVATE_KEY_BLOCK_RE.source, PRIVATE_KEY_BLOCK_RE.flags), "[REDACTED_SECRET]");
result = result.replace(new RegExp(URL_CREDENTIALS_RE.source, URL_CREDENTIALS_RE.flags), "$1[REDACTED_SECRET]@");
for (const source of SECRET_PATTERN_SOURCES) {
const pattern = new RegExp(source.source, source.flags);
result = result.replace(pattern, "[REDACTED_SECRET]");
}
return result;
}
export function scrubRecord<T>(value: T, options: { scrubKeys?: boolean } = {}): T {
if (typeof value === "string") return stripPrivateData(value) as T;
if (Array.isArray(value)) return value.map((item) => scrubRecord(item, options)) as T;
if (value !== null && typeof value === "object") {
const proto = Object.getPrototypeOf(value);
if (proto !== Object.prototype && proto !== null) return value;
const entries = Object.entries(value as Record<string, unknown>).map(([key, item]) => [
options.scrubKeys ? stripPrivateData(key) : key,
item,
] as const);
const reserved = new Set(entries.map(([key]) => key));
const used = new Set<string>();
return Object.fromEntries(
entries.map(([key, item]) => {
let unique = key;
if (used.has(unique)) {
let suffix = 2;
do { unique = `${key}_${suffix++}`; } while (reserved.has(unique) || used.has(unique));
}
used.add(unique);
return [unique, scrubRecord(item, options)];
}),
) as T;
}
return value;
}
export const SCRUBBED_WRITE_FUNCTIONS: ReadonlySet<string> = new Set([
"mem::remember",
"mem::evolve",
"mem::slot-create",
"mem::slot-append",
"mem::slot-replace",
"mem::lesson-save",
"mem::action-create",
"mem::action-update",
"mem::sketch-create",
"mem::sketch-add",
"mem::import",
"mem::mesh-receive",
"mem::team-share",
"mem::signal-send",
"mem::routine-create",
"mem::checkpoint-create",
"mem::checkpoint-resolve",
"mem::sentinel-create",
"mem::sentinel-trigger",
"mem::core-add",
"mem::facet-tag",
]);
type RegisterFunction = (id: string, handler: unknown, ...rest: unknown[]) => unknown;
export function withWriteScrubbing<T extends object>(sdk: T): T {
return new Proxy(sdk, {
get(target, prop) {
const value = Reflect.get(target, prop, target);
if (typeof value !== "function") return value;
if (prop !== "registerFunction") return value.bind(target);
const register = value as RegisterFunction;
return (id: string, handler: unknown, ...rest: unknown[]) => {
if (!SCRUBBED_WRITE_FUNCTIONS.has(id) || typeof handler !== "function") {
return register.call(target, id, handler, ...rest);
}
const original = handler as (data: unknown, ...args: unknown[]) => unknown;
const scrubbed = (data: unknown, ...args: unknown[]) => original(scrubRecord(data), ...args);
return register.call(target, id, scrubbed, ...rest);
};
},
});
}
export function registerPrivacyFunction(sdk: IIIClient): void {
sdk.registerFunction("mem::privacy",
async (data: { input?: unknown } | undefined) => {
if (!data || typeof data.input !== "string") {
return { output: "", error: "invalid input: expected string field 'input'" };
}
return { output: stripPrivateData(data.input) };
},
);
}