hippo-memory 1.52.8 → 1.53.0

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

@@ -0,0 +1,47 @@
+import type { DatabaseSyncLike } from '../db.js';
+import { type MemoryEntry } from '../memory.js';
+import { type Tally } from './report.js';
+import type { AgentMemoryTool } from './tools.js';
+import type { Container } from './types.js';
+export declare const SYNC_ACTOR = "agent-memories";
+export interface StoreSession {
+    readonly db: DatabaseSyncLike;
+    readonly hippoRoot: string;
+    readonly tenantId: string;
+    readonly baseHalfLifeDays: number;
+    /** Stamped on written rows; undefined lets the store stamp its own project. */
+    readonly originProject: string | undefined;
+    /** Whether the text is already stored live by another path, as seen where the new row goes. */
+    readonly isDuplicate: (text: string) => boolean;
+    readonly dryRun: boolean;
+}
+export interface ContainerWork {
+    readonly tool: AgentMemoryTool;
+    readonly container: Container;
+    /** `containerPrefix(tool, containerId)`: every row of the container has a source starting with it. */
+    readonly prefix: string;
+    /** Legacy rows that take an item's key as they are, by key (plan design 10, first round). */
+    readonly adopt: ReadonlyMap<string, readonly MemoryEntry[]>;
+    /** Legacy rows a new row of the key supersedes, by key (second round). */
+    readonly replace: ReadonlyMap<string, readonly MemoryEntry[]>;
+}
+export interface ContainerOutcome {
+    readonly tally: Tally;
+    /** Rows to mirror after commit, as they now stand. */
+    readonly mirror: readonly MemoryEntry[];
+    /** Rows set aside, whose mirrors are purged after commit. */
+    readonly purge: readonly string[];
+}
+/** Throws SQLITE_BUSY when another writer holds the store past its busy timeout; nothing is written then. */
+export declare function syncContainer(s: StoreSession, work: ContainerWork): ContainerOutcome;
+export type SetAsideWhy = 'note-gone' | 'note-changed' | 'handover';
+export type SetAsideResult = {
+    readonly kind: 'untagged';
+    readonly entry: MemoryEntry;
+} | {
+    readonly kind: 'dormant';
+    readonly id: string;
+};
+/** Design 6's set-aside on the caller's transaction: a pinned row only loses the tag, any other goes dormant, restorable. */
+export declare function setAsideRow(db: DatabaseSyncLike, tag: string, row: MemoryEntry, why: SetAsideWhy): SetAsideResult;
+//# sourceMappingURL=apply.d.ts.map

package/dist/agent-memories/apply.js

@@ -0,0 +1,253 @@
+// One container's sync in one transaction on the caller's handle: lookup, plan, then every write (plan designs 6 to 8).
+import { appendAuditEvent } from '../audit.js';
+import { deleteDormantRow, dormantSnapshotsBySourcePrefix, insertDormantRow, readDormantSnapshot } from '../dormant.js';
+import { gatedWrite } from '../gated-write.js';
+import { Layer, calculateStrength, createMemory } from '../memory.js';
+import { findRejectedValue, rejectionDigest } from '../rejection.js';
+import { redactSecretsStrict } from '../secret-detect.js';
+import { deleteEntryRowInTx, markSummaryDirtyInTx, selectLiveEntriesBySourcePrefix, setEntryTagsInTx, stampOriginProject } from '../store.js';
+import { itemHash } from './keys.js';
+import { planContainer } from './plan.js';
+import { emptyTally } from './report.js';
+import { MIN_ITEM_CHARS, itemSource, splitSource, storedText } from './source.js';
+export const SYNC_ACTOR = 'agent-memories';
+/** Throws SQLITE_BUSY when another writer holds the store past its busy timeout; nothing is written then. */
+export function syncContainer(s, work) {
+    // A dry run takes no lock up front and rolls every write back.
+    s.db.exec(s.dryRun ? 'BEGIN' : 'BEGIN IMMEDIATE');
+    try {
+        const out = new ContainerRun(s, work).run();
+        s.db.exec(s.dryRun ? 'ROLLBACK' : 'COMMIT');
+        return out;
+    }
+    catch (err) {
+        try {
+            s.db.exec('ROLLBACK');
+        }
+        catch { /* already rolled back; keep the original error */ }
+        throw err;
+    }
+}
+/** Design 6's set-aside on the caller's transaction: a pinned row only loses the tag, any other goes dormant, restorable. */
+export function setAsideRow(db, tag, row, why) {
+    const untagged = { ...row, tags: row.tags.filter((t) => t !== tag) };
+    const audit = (metadata) => appendAuditEvent(db, { tenantId: row.tenantId, actor: SYNC_ACTOR, op: 'agent_memory_set_aside', targetId: row.id, metadata });
+    if (row.pinned) {
+        setEntryTagsInTx(db, untagged);
+        audit({ why, untagged: true });
+        return { kind: 'untagged', entry: untagged };
+    }
+    const now = new Date();
+    // Sleep's dormant move skips kept rows, so the steps are written out here without its filter.
+    insertDormantRow(db, { entry: untagged, strength: calculateStrength(row, now), reason: 'source-deleted', dormantAt: now.toISOString() });
+    deleteEntryRowInTx(db, row, SYNC_ACTOR);
+    audit({ why });
+    return { kind: 'dormant', id: row.id };
+}
+class ContainerRun {
+    s;
+    w;
+    tally = emptyTally();
+    mirror = [];
+    purge = [];
+    rows = new Map();
+    items = new Map();
+    tag;
+    constructor(s, w) {
+        this.s = s;
+        this.w = w;
+        this.tag = w.tool.tag;
+        for (const item of w.container.items)
+            this.items.set(item.key, item);
+    }
+    run() {
+        this.adoptLegacy();
+        const live = selectLiveEntriesBySourcePrefix(this.s.db, this.s.tenantId, this.w.prefix);
+        for (const row of [...live, ...[...this.w.replace.values()].flat()])
+            this.rows.set(row.id, row);
+        const refusals = this.refusals();
+        const liveRows = live.map((row) => this.liveRow(row));
+        const plan = planContainer({
+            textKeyed: this.w.container.textKeyed,
+            items: this.w.container.items.map((item) => ({ key: item.key, hash: itemHash(item.text), refused: refusals.has(item.key) })),
+            skipped: this.w.container.skipped,
+            live: liveRows,
+            dormant: this.dormantRows(new Set(liveRows.map((r) => r.key)), refusals),
+            legacy: new Map([...this.w.replace].map(([key, rows]) => [key, rows.map((r) => r.id)])),
+            isDuplicate: (item) => this.s.isDuplicate(storedText(this.item(item.key).text)),
+        });
+        for (const reason of refusals.values())
+            this.tally[reason]++;
+        this.tally.unread += this.w.container.skipped.length;
+        this.apply(plan);
+        return { tally: this.tally, mirror: this.mirror, purge: this.purge };
+    }
+    apply(plan) {
+        this.tally.unchanged += plan.unchanged;
+        this.tally.duplicate += plan.duplicates;
+        for (const id of plan.retag)
+            this.retag(this.row(id));
+        for (const { id, by } of plan.collapse)
+            if (this.supersede(this.row(id), by))
+                this.tally.collapsed++;
+        for (const write of plan.writes)
+            this.write(write);
+        for (const { key, dormantId } of plan.restores)
+            this.restore(key, dormantId);
+        for (const id of plan.setAside)
+            this.setAside(this.row(id));
+    }
+    /** Same text as a current note: the legacy row takes the note's key, keeping its id, recall count and outcomes. */
+    adoptLegacy() {
+        for (const [key, rows] of this.w.adopt) {
+            const item = this.items.get(key);
+            if (item === undefined)
+                continue;
+            const source = itemSource(this.w.prefix, key, item.text);
+            for (const row of rows) {
+                const moved = this.s.db.prepare(`UPDATE memories SET source = ? WHERE id = ? AND tenant_id = ? AND source = ? AND superseded_by IS NULL`).run(source, row.id, row.tenantId, row.source);
+                if (Number(moved.changes ?? 0) === 0)
+                    continue;
+                this.tally.adopted++;
+                this.mirror.push({ ...row, source });
+            }
+        }
+    }
+    refusals() {
+        const out = new Map();
+        for (const item of this.w.container.items) {
+            const reason = this.refusal(item);
+            if (reason !== null)
+                out.set(item.key, reason);
+        }
+        return out;
+    }
+    // The rejection lookup reads the capped text, as the write would store it, so a rejected note writes no audit row.
+    refusal(item) {
+        if (item.text.trim().length < MIN_ITEM_CHARS)
+            return 'short';
+        // Imported rows reach prompts, so the bar is text leaving the machine: Bearer headers and JWTs count too.
+        if (redactSecretsStrict(item.text) !== item.text)
+            return 'secret';
+        if (findRejectedValue(this.s.db, this.s.tenantId, rejectionDigest(storedText(item.text))) !== null)
+            return 'rejected';
+        return null;
+    }
+    liveRow(row) {
+        return { id: row.id, ...splitSource(row.source, this.w.prefix), tagged: row.tags.includes(this.tag), created: row.created };
+    }
+    /** Read only when a present key has no live row, which after the first import is rare. */
+    dormantRows(liveKeys, refusals) {
+        const needed = this.w.container.items.some((item) => !refusals.has(item.key) && !liveKeys.has(item.key));
+        if (!needed)
+            return [];
+        return dormantSnapshotsBySourcePrefix(this.s.db, this.s.tenantId, this.w.prefix)
+            .filter((snap) => !snap.entry.superseded_by)
+            .map((snap) => ({ id: snap.entry.id, ...splitSource(snap.entry.source, this.w.prefix), dormantAt: snap.dormantAt }));
+    }
+    retag(row) {
+        const tagged = { ...row, tags: [...row.tags, this.tag] };
+        setEntryTagsInTx(this.s.db, tagged);
+        this.tally.retagged++;
+        this.mirror.push(tagged);
+    }
+    /** api.supersede's steps on this transaction; false when another writer superseded the row first. */
+    supersede(old, newId) {
+        const result = this.s.db.prepare(`UPDATE memories SET superseded_by = ? WHERE id = ? AND tenant_id = ? AND superseded_by IS NULL`)
+            .run(newId, old.id, old.tenantId);
+        if (Number(result.changes ?? 0) === 0)
+            return false;
+        if (old.dag_parent_id)
+            markSummaryDirtyInTx(this.s.db, old.dag_parent_id, old.tenantId, SYNC_ACTOR);
+        appendAuditEvent(this.s.db, { tenantId: old.tenantId, actor: SYNC_ACTOR, op: 'supersede', targetId: old.id, metadata: { newId } });
+        this.mirror.push({ ...old, superseded_by: newId });
+        return true;
+    }
+    write(planned) {
+        const entry = this.newRow(this.item(planned.key));
+        if (!this.gated(entry))
+            return;
+        this.tally[planned.supersedes.length > 0 ? 'replaced' : 'imported']++;
+        for (const id of planned.supersedes)
+            this.supersede(this.row(id), entry.id);
+    }
+    newRow(item) {
+        const base = createMemory(storedText(item.text), {
+            layer: Layer.Episodic,
+            tags: [this.tag],
+            source: itemSource(this.w.prefix, item.key, item.text),
+            confidence: 'observed',
+            kind: 'distilled',
+            tenantId: this.s.tenantId,
+            baseHalfLifeDays: this.s.baseHalfLifeDays,
+        });
+        // The note's own time when it is earlier than now; the loader reads any form but toISOString as drift.
+        const created = Number.isFinite(item.updatedAt)
+            ? new Date(Math.min(item.updatedAt, Date.parse(base.created))).toISOString()
+            : base.created;
+        const origin = this.s.originProject === undefined ? {} : { origin_project: this.s.originProject };
+        return stampOriginProject(this.s.hippoRoot, { ...base, created, valid_from: created, ...origin });
+    }
+    gated(entry) {
+        const result = gatedWrite(this.s.db, this.s.hippoRoot, entry, { actor: SYNC_ACTOR, worthCheck: false });
+        if (result === 'written') {
+            this.mirror.push(entry);
+            return true;
+        }
+        this.tally[result === 'skipped:rejected' ? 'rejected' : 'secret']++;
+        return false;
+    }
+    /** A deleted note came back unchanged: its old row returns with its id and history, under the sync's own audit op. */
+    restore(key, dormantId) {
+        const snap = readDormantSnapshot(this.s.db, this.s.tenantId, dormantId);
+        const taken = this.s.db.prepare(`SELECT 1 FROM memories WHERE id = ?`).get(dormantId) !== undefined;
+        if (snap === null || taken) {
+            this.write({ key, hash: '', supersedes: [] });
+            return;
+        }
+        const now = new Date();
+        const tags = Array.isArray(snap.entry.tags) ? snap.entry.tags.filter((t) => t !== this.tag) : [];
+        const revived = {
+            ...createMemory('dormant snapshot defaults', { baseHalfLifeDays: this.s.baseHalfLifeDays }),
+            ...snap.entry,
+            tags: [...tags, this.tag],
+            last_retrieved: now.toISOString(),
+        };
+        if (!this.gated(stampOriginProject(this.s.hippoRoot, { ...revived, strength: calculateStrength(revived, now) })))
+            return;
+        deleteDormantRow(this.s.db, this.s.tenantId, dormantId);
+        appendAuditEvent(this.s.db, {
+            tenantId: this.s.tenantId,
+            actor: SYNC_ACTOR,
+            op: 'agent_memory_restore',
+            targetId: dormantId,
+            metadata: { reason: snap.reason, dormantAt: snap.dormantAt },
+        });
+        this.tally.restored++;
+    }
+    setAside(row) {
+        const why = this.items.has(splitSource(row.source, this.w.prefix).key) ? 'note-changed' : 'note-gone';
+        const result = setAsideRow(this.s.db, this.tag, row, why);
+        if (result.kind === 'untagged') {
+            this.tally.untagged++;
+            this.mirror.push(result.entry);
+        }
+        else {
+            this.tally.setAside++;
+            this.purge.push(result.id);
+        }
+    }
+    row(id) {
+        const row = this.rows.get(id);
+        if (row === undefined)
+            throw new Error(`agent memory sync: planned row ${id} was not in the lookup`);
+        return row;
+    }
+    item(key) {
+        const item = this.items.get(key);
+        if (item === undefined)
+            throw new Error(`agent memory sync: planned key ${key} was not read`);
+        return item;
+    }
+}
+//# sourceMappingURL=apply.js.map

package/dist/agent-memories/claude-code.d.ts

@@ -0,0 +1,11 @@
+import type { Adapter, AdapterContext, Listing } from './types.js';
+/** Claude Code's auto memory folder names for a project: its checkout, which subfolders share, or the folder itself outside a repository. */
+export declare function claudeMemoryFolderNames(projectRoot: string, platform: NodeJS.Platform): Set<string>;
+/** Claude Code's rule: a linked worktree shares its main checkout's folder, or the git folder's when that sits outside a checkout (a bare repository, or --separate-git-dir); any other checkout, a submodule included, keeps its own. */
+export declare function claudeCheckoutRoot(top: string, gitDir: string, common: string): string;
+/** Claude Code's folder name for a path: non-alphanumerics made '-', and a name over 200 characters cut to 200 plus a base-36 hash of the whole path. */
+export declare function claudeFolderName(root: string): string;
+export declare const claudeCodeAdapter: Adapter;
+/** Post-compact's read: the session's own notes folder and nothing else, so no git call runs inside the hook's time limit. */
+export declare function claudeTranscriptListing(ctx: AdapterContext, transcriptPath: string): Listing;
+//# sourceMappingURL=claude-code.d.ts.map

package/dist/agent-memories/claude-code.js

@@ -0,0 +1,113 @@
+// Claude Code's auto memory: frontmatter `.md` notes in a per-project folder, plus the `autoMemoryDirectory` user folder.
+import fs from 'node:fs';
+import path from 'node:path';
+import { realpathOrResolve } from '../project-identity.js';
+import { isStringValue } from '../capture.js';
+import { isJsonObject } from '../hooks.js';
+import { expandHome, frontmatterField, itemTime, readTextFile, splitFrontmatter } from './files.js';
+import { markdownNotes, readFolderStore, uniqueFolders } from './folder-store.js';
+import { gitLayout } from './git.js';
+// Keeps a pinned name from carrying a separator or `..` out of the projects folder.
+const PROJECT_DIR_NAME = /^[A-Za-z0-9_-]{1,64}$/;
+/** Claude Code's auto memory folder names for a project: its checkout, which subfolders share, or the folder itself outside a repository. */
+export function claudeMemoryFolderNames(projectRoot, platform) {
+    const roots = [projectRoot, realpathOrResolve(projectRoot)];
+    const layout = gitLayout(projectRoot);
+    if (layout)
+        roots.push(claudeCheckoutRoot(layout.top, layout.gitDir, layout.common));
+    return new Set(roots.map((root) => (platform === 'win32' ? claudeFolderName(root).toLowerCase() : claudeFolderName(root))));
+}
+/** Claude Code's rule: a linked worktree shares its main checkout's folder, or the git folder's when that sits outside a checkout (a bare repository, or --separate-git-dir); any other checkout, a submodule included, keeps its own. */
+export function claudeCheckoutRoot(top, gitDir, common) {
+    if (gitDir === common)
+        return top;
+    if (path.basename(common) === '.git')
+        return path.dirname(common);
+    return fs.existsSync(path.join(common, '.git')) ? top : common;
+}
+/** Claude Code's folder name for a path: non-alphanumerics made '-', and a name over 200 characters cut to 200 plus a base-36 hash of the whole path. */
+export function claudeFolderName(root) {
+    const full = path.resolve(root);
+    const name = full.replace(/[^a-zA-Z0-9]/g, '-');
+    if (name.length <= 200)
+        return name;
+    let hash = 0;
+    for (let i = 0; i < full.length; i++)
+        hash = ((hash << 5) - hash + full.charCodeAt(i)) | 0;
+    return `${name.slice(0, 200)}-${Math.abs(hash).toString(36)}`;
+}
+export const claudeCodeAdapter = {
+    tool: 'claude-code',
+    list(ctx, scope) {
+        const config = ctx.env.CLAUDE_CONFIG_DIR || path.join(ctx.home, '.claude');
+        const warnings = [];
+        const folders = scope === 'project' ? projectFolders(ctx, config) : userFolders(ctx, config, warnings);
+        return { tool: 'claude-code', home: config, containers: readFolders(folders, scope, ctx.platform), warnings };
+    },
+};
+/** Post-compact's read: the session's own notes folder and nothing else, so no git call runs inside the hook's time limit. */
+export function claudeTranscriptListing(ctx, transcriptPath) {
+    const config = ctx.env.CLAUDE_CONFIG_DIR || path.join(ctx.home, '.claude');
+    const folder = path.join(path.dirname(transcriptPath), 'memory');
+    return { tool: 'claude-code', home: config, containers: readFolders([folder], 'project', ctx.platform), warnings: [] };
+}
+function projectFolders(ctx, config) {
+    const projects = path.join(config, 'projects');
+    const names = ctx.projectRoot === undefined ? [] : [...claudeMemoryFolderNames(ctx.projectRoot, ctx.platform)];
+    const pinned = ctx.env.CLAUDE_CODE_PROJECT_DIR_NAME;
+    // Claude reads the pinned name only alongside a pinned config folder.
+    if (ctx.env.CLAUDE_CONFIG_DIR && pinned !== undefined && PROJECT_DIR_NAME.test(pinned))
+        names.push(pinned);
+    const folders = names.map((name) => path.join(projects, name, 'memory'));
+    if (ctx.transcriptPath)
+        folders.push(path.join(path.dirname(ctx.transcriptPath), 'memory'));
+    return folders;
+}
+function userFolders(ctx, config, warnings) {
+    const dir = autoMemoryDirectory(path.join(config, 'settings.json'), ctx.home, warnings);
+    return dir === null ? [] : [dir];
+}
+// User settings only: a cloned repository's own settings must not point the import at another project's notes.
+function autoMemoryDirectory(settings, home, warnings) {
+    if (!fs.existsSync(settings))
+        return null;
+    const file = readTextFile(settings);
+    if (!file.ok) {
+        warnings.push(file.reason);
+        return null;
+    }
+    let json;
+    try {
+        // SAFETY: JSON.parse yields JSON; the object and string checks below decide what is used.
+        json = JSON.parse(file.text);
+    }
+    catch (err) {
+        warnings.push(`${settings}: ${err instanceof Error ? err.message : String(err)}`);
+        return null;
+    }
+    const value = isJsonObject(json) ? json.autoMemoryDirectory : undefined;
+    if (!isStringValue(value) || value === '')
+        return null;
+    const dir = expandHome(value, home);
+    if (path.isAbsolute(dir))
+        return dir;
+    warnings.push(`${settings}: autoMemoryDirectory "${value}" is not absolute or under ~/, so it is ignored`);
+    return null;
+}
+// Claude counts a note only when it carries frontmatter; `modified` there beats the file time.
+const NOTES = {
+    recursive: false,
+    include: markdownNotes,
+    item(text, mtimeMs) {
+        const { yaml, body } = splitFrontmatter(text);
+        if (yaml === null)
+            return null;
+        return { text: body.trim(), updatedAt: itemTime(frontmatterField(yaml, 'modified'), mtimeMs) };
+    },
+};
+function readFolders(folders, scope, platform) {
+    return uniqueFolders(folders, platform)
+        .map((dir) => readFolderStore(dir, scope, NOTES))
+        .filter((c) => c !== null);
+}
+//# sourceMappingURL=claude-code.js.map

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

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

package/dist/agent-memories/codex.js

@@ -0,0 +1,47 @@
+// Codex CLI's memory_summary.md, the one memory file Codex puts in its prompt, read as a single text-keyed file.
+import fs from 'node:fs';
+import path from 'node:path';
+import { codexHomeDir } from '../hooks.js';
+import { readTextFile } from './files.js';
+import { textItemKeys } from './keys.js';
+import { splitMarkdownItems } from './markdown.js';
+// "What's in Memory" only indexes MEMORY.md, so it is left out.
+const KEPT_HEADINGS = new Set(['user profile', 'user preferences', 'general tips']);
+const PROFILE_HEADING = /^##[ \t]+User Profile[ \t]*$/im;
+export const codexAdapter = {
+    tool: 'codex',
+    list(ctx, scope) {
+        const home = codexHomeDir(ctx.home, ctx.env);
+        const containers = [];
+        if (scope === 'user') {
+            const container = readSummary(path.join(home, 'memories', 'memory_summary.md'));
+            if (container !== null)
+                containers.push(container);
+        }
+        return { tool: 'codex', home, containers, warnings: [] };
+    },
+};
+function readSummary(file) {
+    if (!fs.existsSync(file))
+        return null;
+    const read = readTextFile(file);
+    if (!read.ok)
+        return unreadable(file, read.reason);
+    if (!isCodexSummary(read.text)) {
+        return unreadable(file, `${file}: not a Codex memory summary (needs "v1" first and a "## User Profile" heading)`);
+    }
+    const kept = splitMarkdownItems(read.text)
+        .filter((item) => KEPT_HEADINGS.has(item.heading.trim().toLowerCase()))
+        .map((item) => ({ headingSlug: item.headingSlug, text: `${item.heading}: ${item.text}` }));
+    const keys = textItemKeys(kept);
+    const items = kept.map(({ text }, i) => ({ key: keys[i], text, updatedAt: read.mtimeMs }));
+    return { scope: 'user', path: file, readable: true, items, skipped: [], warnings: [], textKeyed: true };
+}
+function isCodexSummary(text) {
+    const first = text.split(/\r?\n/).find((line) => line.trim() !== '');
+    return first?.trim() === 'v1' && PROFILE_HEADING.test(text);
+}
+function unreadable(file, warning) {
+    return { scope: 'user', path: file, readable: false, items: [], skipped: [], warnings: [warning], textKeyed: true };
+}
+//# sourceMappingURL=codex.js.map

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