hippo-memory 1.52.9 → 1.53.1

package/dist/agent-memories/copilot.d.ts

@@ -0,0 +1,3 @@
+import type { Adapter } from './types.js';
+export declare const copilotAdapter: Adapter;
+//# sourceMappingURL=copilot.d.ts.map

package/dist/agent-memories/copilot.js

@@ -0,0 +1,125 @@
+// GitHub Copilot Chat in VS Code: memory-tool files under VS Code's own data folders, one set per product and workspace.
+import fs from 'node:fs';
+import path from 'node:path';
+import { readTextFile } from './files.js';
+import { readFolderStore } from './folder-store.js';
+import { gitLayout } from './git.js';
+const PRODUCTS = ['Code', 'Code - Insiders'];
+const MEMORY_TOOL = ['github.copilot-chat', 'memory-tool', 'memories'];
+/** VS Code's user-data resolution: portable install first, then the app-data override, then the platform default. */
+function dataFolders(ctx) {
+    const { env, home, platform } = ctx;
+    if (env.VSCODE_PORTABLE)
+        return [path.join(env.VSCODE_PORTABLE, 'user-data')];
+    let appData;
+    if (env.VSCODE_APPDATA)
+        appData = env.VSCODE_APPDATA;
+    else if (platform === 'win32')
+        appData = env.APPDATA || path.join(home, 'AppData', 'Roaming');
+    else if (platform === 'darwin')
+        appData = path.join(home, 'Library', 'Application Support');
+    else
+        appData = env.XDG_CONFIG_HOME || path.join(home, '.config');
+    return PRODUCTS.map((product) => path.join(appData, product));
+}
+/** A `file:` URI as a local path; null for any other scheme or a URI with a host part. */
+function fileUriToPath(uri, platform) {
+    if (!uri.startsWith('file://'))
+        return null;
+    const rest = decodeURIComponent(uri.slice('file://'.length));
+    if (!rest.startsWith('/'))
+        return null;
+    return platform === 'win32' ? rest.replace(/^\/(?=[a-zA-Z]:)/, '').replace(/\//g, '\\') : rest;
+}
+/** The workspace's single folder as a path; null (with a warning when the file is unusable) for anything else. */
+function workspaceFolder(file, platform, warnings) {
+    const read = readTextFile(file);
+    if (!read.ok) {
+        warnings.push(read.reason);
+        return null;
+    }
+    try {
+        // SAFETY: JSON.parse output; a non-string `folder` or a scalar file throws below and becomes a warning.
+        const json = JSON.parse(read.text);
+        if (json === null || Array.isArray(json))
+            throw new Error('not a JSON object');
+        if ('workspace' in json || !json.folder)
+            return null;
+        return fileUriToPath(json.folder, platform);
+    }
+    catch (err) {
+        warnings.push(`${file}: ${err instanceof Error ? err.message : String(err)}`);
+        return null;
+    }
+}
+/** Matches the project root exactly, or its git top level; git is asked once, and only when a folder needs it. */
+function projectMatcher(projectRoot, platform) {
+    const fold = (p) => (platform === 'win32' ? p.toLowerCase() : p);
+    const root = fold(path.resolve(projectRoot));
+    let top;
+    return (folder) => {
+        const wanted = fold(folder);
+        if (wanted === root)
+            return true;
+        if (top === undefined) {
+            const layout = gitLayout(projectRoot);
+            top = layout === null ? null : fold(path.resolve(layout.top));
+        }
+        return wanted === top;
+    };
+}
+const EVERY_FILE = {
+    recursive: true,
+    include: () => true,
+    item: (text, mtimeMs) => ({ text: text.trim(), updatedAt: mtimeMs }),
+};
+function isDirectory(p) {
+    return fs.statSync(p, { throwIfNoEntry: false })?.isDirectory() === true;
+}
+function projectContainers(data, ctx, matches, warnings) {
+    const storage = path.join(data, 'User', 'workspaceStorage');
+    if (!fs.existsSync(storage))
+        return [];
+    let ids;
+    try {
+        ids = fs.readdirSync(storage, { withFileTypes: true }).filter((e) => e.isDirectory()).map((e) => e.name).sort();
+    }
+    catch (err) {
+        warnings.push(`${storage}: ${err instanceof Error ? err.message : String(err)}`);
+        return [];
+    }
+    const found = [];
+    for (const id of ids) {
+        const repo = path.join(storage, id, ...MEMORY_TOOL, 'repo');
+        if (!isDirectory(repo))
+            continue;
+        const folder = workspaceFolder(path.join(storage, id, 'workspace.json'), ctx.platform, warnings);
+        const container = folder !== null && matches(folder) ? readFolderStore(repo, 'project', EVERY_FILE) : null;
+        if (container)
+            found.push(container);
+    }
+    return found;
+}
+export const copilotAdapter = {
+    tool: 'copilot',
+    list(ctx, scope) {
+        const data = dataFolders(ctx);
+        const warnings = [];
+        const found = [];
+        if (scope === 'user') {
+            for (const dir of data) {
+                const container = readFolderStore(path.join(dir, 'User', 'globalStorage', ...MEMORY_TOOL), 'user', EVERY_FILE);
+                if (container)
+                    found.push(container);
+            }
+        }
+        else if (ctx.projectRoot !== undefined) {
+            const matches = projectMatcher(ctx.projectRoot, ctx.platform);
+            for (const dir of data)
+                found.push(...projectContainers(dir, ctx, matches, warnings));
+        }
+        const home = data.find((dir) => fs.existsSync(dir)) ?? data[0];
+        return { tool: 'copilot', home, containers: found, warnings };
+    },
+};
+//# sourceMappingURL=copilot.js.map

package/dist/agent-memories/files.d.ts

@@ -0,0 +1,37 @@
+export declare const MAX_ITEM_BYTES: number;
+export type TextFile = {
+    readonly ok: true;
+    readonly text: string;
+    readonly mtimeMs: number;
+} | {
+    readonly ok: false;
+    readonly reason: string;
+};
+/** A file's text, or why it was skipped: empty, too big, holds a NUL byte (not text), or unreadable. */
+export declare function readTextFile(file: string): TextFile;
+export type DirListing = {
+    readonly status: 'ok';
+    readonly files: readonly string[];
+} | {
+    readonly status: 'missing';
+} | {
+    readonly status: 'unreadable';
+    readonly reason: string;
+};
+/** Files in a folder as '/'-separated relative paths, sorted; dot entries skipped, symlinked folders not followed. */
+export declare function listFiles(dir: string, opts: {
+    recursive: boolean;
+}): DirListing;
+export interface Frontmatter {
+    /** The YAML between the fences, or null when the file has none. */
+    readonly yaml: string | null;
+    readonly body: string;
+}
+export declare function splitFrontmatter(raw: string): Frontmatter;
+/** One top-level scalar from frontmatter YAML, quotes removed; enough for `modified`, no YAML parser needed. */
+export declare function frontmatterField(yaml: string, field: string): string | null;
+/** An item's time: the date string when it parses and is not in the future, else the fallback. */
+export declare function itemTime(dateText: string | null, fallbackMs: number, nowMs?: number): number;
+/** `~/x` against the given home; anything else unchanged. */
+export declare function expandHome(p: string, home: string): string;
+//# sourceMappingURL=files.d.ts.map

package/dist/agent-memories/files.js

@@ -0,0 +1,77 @@
+// Read-only file access shared by the adapters: size, binary and failure checks live in one place.
+import fs from 'node:fs';
+import path from 'node:path';
+export const MAX_ITEM_BYTES = 256 * 1024;
+const MAX_DEPTH = 8;
+/** A file's text, or why it was skipped: empty, too big, holds a NUL byte (not text), or unreadable. */
+export function readTextFile(file) {
+    try {
+        const stat = fs.statSync(file);
+        if (!stat.isFile())
+            return { ok: false, reason: `${file}: not a file` };
+        // A tool rewriting a file truncates it first; read as holding no notes, every row would be set aside.
+        if (stat.size === 0)
+            return { ok: false, reason: `${file}: empty` };
+        if (stat.size > MAX_ITEM_BYTES)
+            return { ok: false, reason: `${file}: over ${MAX_ITEM_BYTES} bytes` };
+        const buf = fs.readFileSync(file);
+        if (buf.includes(0))
+            return { ok: false, reason: `${file}: not text` };
+        return { ok: true, text: buf.toString('utf8'), mtimeMs: stat.mtimeMs };
+    }
+    catch (err) {
+        return { ok: false, reason: `${file}: ${err instanceof Error ? err.message : String(err)}` };
+    }
+}
+/** Files in a folder as '/'-separated relative paths, sorted; dot entries skipped, symlinked folders not followed. */
+export function listFiles(dir, opts) {
+    if (!fs.existsSync(dir))
+        return { status: 'missing' };
+    try {
+        if (!fs.statSync(dir).isDirectory())
+            return { status: 'unreadable', reason: `${dir}: not a folder` };
+        const files = [];
+        walk(dir, '', opts.recursive ? MAX_DEPTH : 0, files);
+        return { status: 'ok', files: files.sort() };
+    }
+    catch (err) {
+        return { status: 'unreadable', reason: `${dir}: ${err instanceof Error ? err.message : String(err)}` };
+    }
+}
+function walk(root, rel, depthLeft, out) {
+    for (const entry of fs.readdirSync(path.join(root, rel), { withFileTypes: true })) {
+        if (entry.name.startsWith('.'))
+            continue;
+        const child = rel === '' ? entry.name : `${rel}/${entry.name}`;
+        if (entry.isFile() || (entry.isSymbolicLink() && isFile(path.join(root, child))))
+            out.push(child);
+        else if (entry.isDirectory() && depthLeft > 0)
+            walk(root, child, depthLeft - 1, out);
+    }
+}
+function isFile(p) {
+    return fs.statSync(p, { throwIfNoEntry: false })?.isFile() === true;
+}
+const FRONTMATTER = /^---\r?\n([\s\S]*?)\r?\n---\r?\n([\s\S]*)$/;
+export function splitFrontmatter(raw) {
+    const m = raw.match(FRONTMATTER);
+    return m ? { yaml: m[1], body: m[2] } : { yaml: null, body: raw };
+}
+/** One top-level scalar from frontmatter YAML, quotes removed; enough for `modified`, no YAML parser needed. */
+export function frontmatterField(yaml, field) {
+    const m = yaml.match(new RegExp(`^${field}:[ \\t]*(.+?)[ \\t]*$`, 'm'));
+    if (!m)
+        return null;
+    return m[1].replace(/^(['"])(.*)\1$/, '$2');
+}
+/** An item's time: the date string when it parses and is not in the future, else the fallback. */
+export function itemTime(dateText, fallbackMs, nowMs = Date.now()) {
+    const parsed = dateText === null ? NaN : Date.parse(dateText);
+    const t = Number.isFinite(parsed) ? parsed : fallbackMs;
+    return Math.min(t, nowMs);
+}
+/** `~/x` against the given home; anything else unchanged. */
+export function expandHome(p, home) {
+    return p === '~' ? home : p.startsWith('~/') || p.startsWith('~\\') ? path.join(home, p.slice(2)) : p;
+}
+//# sourceMappingURL=files.js.map

package/dist/agent-memories/folder-store.d.ts

@@ -0,0 +1,17 @@
+import type { Container, Scope } from './types.js';
+export interface FolderRules {
+    readonly recursive: boolean;
+    readonly include: (rel: string) => boolean;
+    /** The stored text and time of a file read in full, or null when the tool would not count it as a note. */
+    readonly item: (text: string, mtimeMs: number) => {
+        readonly text: string;
+        readonly updatedAt: number;
+    } | null;
+}
+/** Null when the folder is missing; a file that could not be read is `skipped`, so its row is left alone. */
+export declare function readFolderStore(dir: string, scope: Scope, rules: FolderRules): Container | null;
+/** Markdown notes directly in, or anywhere under, the folder, with the tool's index file left out. */
+export declare function markdownNotes(rel: string): boolean;
+/** Each folder once, compared case-insensitively on win32 as the file system does. */
+export declare function uniqueFolders(folders: readonly string[], platform: NodeJS.Platform): string[];
+//# sourceMappingURL=folder-store.d.ts.map

package/dist/agent-memories/folder-store.js

@@ -0,0 +1,44 @@
+// A folder whose files are the items, as Claude Code, Gemini, Qwen and Copilot keep them: one reader for all four.
+import path from 'node:path';
+import { listFiles, readTextFile } from './files.js';
+/** Null when the folder is missing; a file that could not be read is `skipped`, so its row is left alone. */
+export function readFolderStore(dir, scope, rules) {
+    const listing = listFiles(dir, { recursive: rules.recursive });
+    if (listing.status === 'missing')
+        return null;
+    if (listing.status === 'unreadable') {
+        return { scope, path: dir, readable: false, items: [], skipped: [], warnings: [listing.reason], textKeyed: false };
+    }
+    const items = [];
+    const skipped = [];
+    const warnings = [];
+    for (const key of listing.files.filter(rules.include)) {
+        const file = readTextFile(path.join(dir, key));
+        if (!file.ok) {
+            skipped.push(key);
+            warnings.push(file.reason);
+            continue;
+        }
+        const item = rules.item(file.text, file.mtimeMs);
+        if (item !== null)
+            items.push({ key, ...item });
+    }
+    return { scope, path: dir, readable: true, items, skipped, warnings, textKeyed: false };
+}
+/** Markdown notes directly in, or anywhere under, the folder, with the tool's index file left out. */
+export function markdownNotes(rel) {
+    return rel.endsWith('.md') && rel !== 'MEMORY.md';
+}
+/** Each folder once, compared case-insensitively on win32 as the file system does. */
+export function uniqueFolders(folders, platform) {
+    const seen = new Set();
+    return folders.filter((folder) => {
+        const resolved = path.resolve(folder);
+        const key = platform === 'win32' ? resolved.toLowerCase() : resolved;
+        if (seen.has(key))
+            return false;
+        seen.add(key);
+        return true;
+    });
+}
+//# sourceMappingURL=folder-store.js.map

package/dist/agent-memories/gemini.d.ts

@@ -0,0 +1,3 @@
+import type { Adapter } from './types.js';
+export declare const geminiAdapter: Adapter;
+//# sourceMappingURL=gemini.d.ts.map

package/dist/agent-memories/gemini.js

@@ -0,0 +1,103 @@
+// Gemini CLI: the "Gemini Added Memories" section of GEMINI.md, and the auto-memory folder that projects.json names.
+import fs from 'node:fs';
+import path from 'node:path';
+import { isStringValue } from '../capture.js';
+import { isJsonObject } from '../hooks.js';
+import { readTextFile, splitFrontmatter } from './files.js';
+import { markdownNotes, readFolderStore } from './folder-store.js';
+import { gitLayout } from './git.js';
+import { textItemKeys } from './keys.js';
+import { splitMarkdownItems } from './markdown.js';
+const SECTION = 'gemini added memories';
+export const geminiAdapter = {
+    tool: 'gemini',
+    list(ctx, scope) {
+        const home = path.join(ctx.env.GEMINI_CLI_HOME || ctx.home, '.gemini');
+        if (scope === 'user')
+            return { tool: 'gemini', home, containers: userContainers(home), warnings: [] };
+        return projectListing(ctx, home);
+    },
+};
+function refused(scope, file, reason, textKeyed) {
+    return { scope, path: file, readable: false, items: [], skipped: [], warnings: [reason], textKeyed };
+}
+function userContainers(home) {
+    const file = path.join(home, 'GEMINI.md');
+    if (!fs.existsSync(file))
+        return [];
+    const read = readTextFile(file);
+    if (!read.ok)
+        return [refused('user', file, read.reason, true)];
+    const kept = splitMarkdownItems(read.text).filter((item) => item.heading.toLowerCase() === SECTION);
+    const keys = textItemKeys(kept);
+    const items = kept.map((item, i) => ({ key: keys[i], text: item.text, updatedAt: read.mtimeMs }));
+    return [{ scope: 'user', path: file, readable: true, items, skipped: [], warnings: [], textKeyed: true }];
+}
+function projectListing(ctx, home) {
+    const warnings = [];
+    const containers = [];
+    if (ctx.projectRoot !== undefined) {
+        const slug = projectSlug(ctx, ctx.projectRoot, home, warnings);
+        const container = slug === null ? null : readFolderStore(path.join(home, 'tmp', slug, 'memory'), 'project', NOTES);
+        if (container !== null)
+            containers.push(container);
+    }
+    return { tool: 'gemini', home, containers, warnings };
+}
+function projectSlug(ctx, projectRoot, home, warnings) {
+    const index = path.join(home, 'projects.json');
+    if (!fs.existsSync(index))
+        return null;
+    const read = readTextFile(index);
+    if (!read.ok) {
+        warnings.push(read.reason);
+        return null;
+    }
+    let projects;
+    try {
+        projects = parseIndex(read.text);
+    }
+    catch (err) {
+        warnings.push(`${index}: ${err instanceof Error ? err.message : String(err)}`);
+        return null;
+    }
+    // The git top level is only asked for when the folder itself has no entry, since it spawns git.
+    const entry = findEntry(projects, projectRoot, ctx.platform) ?? topEntry(projects, projectRoot, ctx.platform);
+    if (entry === undefined)
+        return null;
+    const [key, slug] = entry;
+    if (isStringValue(slug) && isPlainName(slug))
+        return slug;
+    warnings.push(`${index}: the slug for ${key} is not a plain folder name`);
+    return null;
+}
+function parseIndex(text) {
+    // SAFETY: JSON.parse yields JSON; the object checks below decide what is used.
+    const data = JSON.parse(text);
+    const projects = isJsonObject(data) ? data.projects : undefined;
+    if (!isJsonObject(projects))
+        throw new Error('expected { "projects": { "<absolute path>": "<slug>" } }');
+    return projects;
+}
+function isPlainName(slug) {
+    return slug !== '' && slug !== '.' && slug !== '..' && !/[\\/]/.test(slug);
+}
+function fold(p, platform) {
+    const resolved = path.resolve(p);
+    return platform === 'win32' ? resolved.toLowerCase() : resolved;
+}
+// A relative key would resolve against the working folder, which no adapter may read.
+function findEntry(projects, target, platform) {
+    const want = fold(target, platform);
+    return Object.entries(projects).find(([key]) => path.isAbsolute(key) && fold(key, platform) === want);
+}
+function topEntry(projects, projectRoot, platform) {
+    const top = gitLayout(projectRoot)?.top;
+    return top === undefined ? undefined : findEntry(projects, top, platform);
+}
+const NOTES = {
+    recursive: false,
+    include: markdownNotes,
+    item: (text, mtimeMs) => ({ text: splitFrontmatter(text).body.trim(), updatedAt: mtimeMs }),
+};
+//# sourceMappingURL=gemini.js.map

package/dist/agent-memories/git.d.ts

@@ -0,0 +1,8 @@
+export interface GitLayout {
+    readonly top: string;
+    readonly gitDir: string;
+    readonly common: string;
+}
+/** Null outside a repository or when git fails; a missing folder name then only means fewer containers listed. */
+export declare function gitLayout(projectRoot: string): GitLayout | null;
+//# sourceMappingURL=git.d.ts.map

package/dist/agent-memories/git.js

@@ -0,0 +1,11 @@
+// The git layout of a project root, which Claude Code, Gemini and Copilot use to name a project's memory folder.
+import { spawnSync } from 'node:child_process';
+/** Null outside a repository or when git fails; a missing folder name then only means fewer containers listed. */
+export function gitLayout(projectRoot) {
+    const git = spawnSync('git', ['rev-parse', '--path-format=absolute', '--show-toplevel', '--absolute-git-dir', '--git-common-dir'], { cwd: projectRoot, encoding: 'utf8', timeout: 10000, windowsHide: true });
+    if (git.status !== 0)
+        return null;
+    const [top, gitDir, common] = git.stdout.trim().split(/\r?\n/);
+    return top && gitDir && common ? { top, gitDir, common } : null;
+}
+//# sourceMappingURL=git.js.map

package/dist/agent-memories/keys.d.ts

@@ -0,0 +1,9 @@
+export declare function sha256Hex(text: string): string;
+/** The `#<hash>` part of a source: 16 hex of the full text, so an edit past the content cap is still seen. */
+export declare function itemHash(text: string): string;
+/** Keys for a single-file store's items: `<heading slug>/<12 hex of the text>`, `~2`, `~3` on repeats. */
+export declare function textItemKeys(items: readonly {
+    readonly headingSlug: string;
+    readonly text: string;
+}[]): string[];
+//# sourceMappingURL=keys.d.ts.map

package/dist/agent-memories/keys.js

@@ -0,0 +1,20 @@
+// Hashes and keys for imported items, shared by the sync and the single-file adapters so they never drift apart.
+import { createHash } from 'node:crypto';
+export function sha256Hex(text) {
+    return createHash('sha256').update(text.replace(/\r\n/g, '\n'), 'utf8').digest('hex');
+}
+/** The `#<hash>` part of a source: 16 hex of the full text, so an edit past the content cap is still seen. */
+export function itemHash(text) {
+    return sha256Hex(text).slice(0, 16);
+}
+/** Keys for a single-file store's items: `<heading slug>/<12 hex of the text>`, `~2`, `~3` on repeats. */
+export function textItemKeys(items) {
+    const seen = new Map();
+    return items.map(({ headingSlug, text }) => {
+        const base = `${headingSlug}/${sha256Hex(text).slice(0, 12)}`;
+        const n = (seen.get(base) ?? 0) + 1;
+        seen.set(base, n);
+        return n === 1 ? base : `${base}~${n}`;
+    });
+}
+//# sourceMappingURL=keys.js.map

package/dist/agent-memories/legacy.d.ts

@@ -0,0 +1,17 @@
+import type { DatabaseSyncLike } from '../db.js';
+import type { MemoryEntry } from '../memory.js';
+import type { Listing } from './types.js';
+export declare const LEGACY_SOURCE_PREFIX = "claude-memory:";
+export interface ContainerLegacy {
+    readonly adopt: Map<string, MemoryEntry[]>;
+    readonly replace: Map<string, MemoryEntry[]>;
+}
+export interface LegacyWork {
+    /** By container path. */
+    readonly byContainer: ReadonlyMap<string, ContainerLegacy>;
+    /** Rows about to take a note's key, which stop counting as text another path stored. */
+    readonly adopted: ReadonlySet<string>;
+}
+/** Matched once across all the store's Claude folders, before any container's transaction; each adoption re-checks its row inside one. */
+export declare function legacyWork(db: DatabaseSyncLike, tenantId: string, listings: readonly Listing[]): LegacyWork;
+//# sourceMappingURL=legacy.d.ts.map

package/dist/agent-memories/legacy.js

@@ -0,0 +1,45 @@
+// Rows the old Claude import wrote (`claude-memory:<file>`), taken over by the notes they came from (plan design 10).
+import path from 'node:path';
+import { duplicateKey } from '../same-text.js';
+import { selectLiveEntriesBySourcePrefix } from '../store.js';
+import { matchLegacy } from './plan.js';
+import { MIN_ITEM_CHARS, storedText } from './source.js';
+export const LEGACY_SOURCE_PREFIX = 'claude-memory:';
+const LEGACY_TAG = 'claude-code-memory';
+/** Matched once across all the store's Claude folders, before any container's transaction; each adoption re-checks its row inside one. */
+export function legacyWork(db, tenantId, listings) {
+    const containers = listings.filter((l) => l.tool === 'claude-code').flatMap((l) => l.containers).filter((c) => c.readable);
+    const rows = containers.length === 0
+        ? []
+        : selectLiveEntriesBySourcePrefix(db, tenantId, LEGACY_SOURCE_PREFIX).filter((r) => r.tags.includes(LEGACY_TAG));
+    const byContainer = new Map();
+    if (rows.length === 0)
+        return { byContainer, adopted: new Set() };
+    const refs = [];
+    const targets = [];
+    for (const container of containers) {
+        for (const item of container.items) {
+            if (item.text.trim().length < MIN_ITEM_CHARS)
+                continue;
+            targets.push({ ref: String(refs.length), file: path.posix.basename(item.key), textKey: duplicateKey(storedText(item.text)) });
+            refs.push({ dir: container.path, key: item.key });
+        }
+    }
+    const match = matchLegacy(rows.map((r) => ({ id: r.id, file: r.source.slice(LEGACY_SOURCE_PREFIX.length), textKey: duplicateKey(r.content) })), targets);
+    const byId = new Map(rows.map((r) => [r.id, r]));
+    const add = (pick, ref, id) => {
+        const { dir, key } = refs[Number(ref)];
+        const row = byId.get(id);
+        if (row === undefined)
+            return;
+        const found = byContainer.get(dir) ?? { adopt: new Map(), replace: new Map() };
+        byContainer.set(dir, found);
+        found[pick].set(key, [...(found[pick].get(key) ?? []), row]);
+    };
+    for (const [id, ref] of match.adopt)
+        add('adopt', ref, id);
+    for (const [ref, id] of match.replace)
+        add('replace', ref, id);
+    return { byContainer, adopted: new Set(match.adopt.keys()) };
+}
+//# sourceMappingURL=legacy.js.map

package/dist/agent-memories/markdown.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Splits one markdown memory file into items (a top-level bullet or a paragraph), each tagged with its heading. Pure.
+ */
+export interface MarkdownItem {
+    readonly heading: string;
+    readonly headingSlug: string;
+    readonly text: string;
+}
+/** Lowercase, punctuation runs folded to '-', cut to 40 characters; 'top' when nothing is left. */
+export declare function slugHeading(heading: string): string;
+/** Split markdown into memory items in file order; headings set context and are never items. */
+export declare function splitMarkdownItems(markdown: string): MarkdownItem[];
+//# sourceMappingURL=markdown.d.ts.map