opencode-harnmem 0.0.0-stage → 0.1.0

package/vendor/core/store.d.ts

@@ -0,0 +1,145 @@
+import { dirname } from "node:path";
+import type { MemoryRecord, MemoryScope, TranscriptMessage } from "./types.js";
+export interface ShardRef {
+    scope: MemoryScope;
+    /** projectId for project scope; undefined for user scope. */
+    project?: string;
+    /** Directory name used in paths, e.g. "user" or the projectId. */
+    name: string;
+}
+export interface ShardRecords {
+    shard: ShardRef;
+    records: MemoryRecord[];
+    errors: {
+        file: string;
+        message: string;
+    }[];
+}
+export interface AuditEntry {
+    seq?: number;
+    ts: number;
+    kind: string;
+    harness?: string;
+    session?: string;
+    [key: string]: unknown;
+}
+export interface DigestEntry {
+    name: string;
+    title: string;
+    body: string;
+    updated?: number;
+}
+export interface UsageEntry {
+    lastUsed: number;
+    usedCount: number;
+}
+export declare class Store {
+    readonly home: string;
+    private seqCache;
+    private shardSeqCache;
+    constructor(home: string);
+    path(...parts: string[]): string;
+    get memoriesDir(): string;
+    get stateDir(): string;
+    get indexPath(): string;
+    get trashDir(): string;
+    init(): Promise<void>;
+    shardRef(scope: MemoryScope, projectId?: string): ShardRef;
+    shardDir(shard: ShardRef): string;
+    indexFile(shard: ShardRef): string;
+    digestDir(shard: ShardRef): string;
+    recordPath(shard: ShardRef, id: string): string;
+    listShards(): Promise<ShardRef[]>;
+    /** Read every `.md` file in a shard (excluding MEMORY.md). */
+    readShard(shard: ShardRef): Promise<ShardRecords>;
+    readRecord(shard: ShardRef, id: string): Promise<MemoryRecord | null>;
+    /** Find a record by id across all shards (cheap scan; ids are unique). */
+    findRecord(id: string): Promise<{
+        record: MemoryRecord;
+        shard: ShardRef;
+    } | null>;
+    writeRecord(shard: ShardRef, record: MemoryRecord): Promise<void>;
+    /** Bulk write (import/migration): files first, index once, seq once. */
+    writeRecordsBulk(shard: ShardRef, records: MemoryRecord[]): Promise<void>;
+    /** Update MEMORY.md one line at a time (index is derived, safe to rebuild). */
+    private upsertIndexLine;
+    /** Move a record file to trash (soft delete for `forget`). */
+    moveToTrash(shard: ShardRef, record: MemoryRecord, now: number): Promise<string>;
+    getSeq(): Promise<number>;
+    /**
+     * Per-shard sequence: index validity is checked against it, so a write to one
+     * project never invalidates unrelated shard indexes (global seq invalidates all).
+     */
+    getShardSeq(name: string): Promise<number>;
+    /** Read the seq from disk, bypassing the in-process cache (cross-process freshness). */
+    peekSeq(): Promise<number>;
+    bumpSeq(shardName?: string): Promise<number>;
+    audit(entry: Omit<AuditEntry, "seq"> & {
+        seq?: number;
+    }): Promise<void>;
+    getCursor(key: string): Promise<string | null>;
+    setCursor(key: string, value: string): Promise<void>;
+    private usageCache;
+    /**
+     * Usage counters live in `state/usage.json`, not in the memory files: a search
+     * touches up to `budget` records, and rewriting N markdown files per query
+     * (plus invalidating every shard index) does not scale. Memory files stay the
+     * SSOT for content; `doctor --merge-usage` folds these counters back into the
+     * frontmatter when it matters.
+     */
+    loadUsage(): Promise<Map<string, UsageEntry>>;
+    /** Persist usage counters (lastUsed/usedCount) touched by searches. */
+    saveUsage(updates: Map<string, UsageEntry>): Promise<void>;
+    /**
+     * Session journal entry (only what extraction needs).
+     *
+     * Idempotent per message: re-persisting a snapshot that already covers
+     * messages from an earlier process (the adapter rehydrates its digest from
+     * this journal) appends only the lines that are not already present.
+     */
+    appendSession(input: {
+        harness: string;
+        sessionId: string;
+        cwd: string;
+        date?: string;
+        messages: {
+            role: string;
+            text: string;
+            ts?: number;
+        }[];
+    }): Promise<void>;
+    /**
+     * Read one session's persisted journal across day directories, oldest first,
+     * deduplicated and bounded to the last 200 messages.
+     *
+     * DSH resumes a session in a new process without replaying earlier events, so
+     * an adapter that only kept a process-local digest would always hit the
+     * `too_few_messages` gate at the next quit. Adapters use this to rehydrate.
+     */
+    readSessionTranscript(harness: string, sessionId: string): Promise<TranscriptMessage[]>;
+    listDigests(shard: ShardRef): Promise<DigestEntry[]>;
+    /** Load/save per-shard search index JSON. */
+    loadIndex(name: string): Promise<unknown | null>;
+    saveIndex(name: string, value: unknown): Promise<void>;
+    readManifest(): Promise<{
+        version: number;
+        seq: number;
+        shards: unknown[];
+    } | null>;
+    writeManifest(seq: number, shards: unknown[]): Promise<void>;
+    /** Rebuild human-readable MEMORY.md for a shard from its files. */
+    rebuildIndexFile(shard: ShardRef): Promise<number>;
+    stats(): Promise<{
+        memories: number;
+        user: number;
+        projects: Record<string, number>;
+        archived: number;
+        superseded: number;
+        trash: number;
+        digests: number;
+    }>;
+}
+export declare function shardKey(shard: ShardRef): string;
+export declare function shardFromName(name: string): ShardRef;
+export { dirname };
+//# sourceMappingURL=store.d.ts.map

package/vendor/core/store.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"store.d.ts","sourceRoot":"","sources":["../src/store.ts"],"names":[],"mappings":"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"}

package/vendor/core/store.js

@@ -0,0 +1,511 @@
+/**
+ * Filesystem store: the single source of truth. One directory per scope shard,
+ * one markdown file per memory, JSON for state/index. No database.
+ *
+ * Layout (docs/design/02-data-model.md):
+ *   memories/user/<id>.md
+ *   memories/projects/<projectId>/<id>.md
+ *   state/seq, state/audit.jsonl, state/cursors.json
+ *   index/manifest.json, index/<shard>.json
+ *   digests/<shard>/*.md
+ *   sessions/<date>/<harness>_<id>.jsonl
+ *   trash/<ts>-<id>.md
+ */
+import { promises as fs } from "node:fs";
+import { basename, dirname, join } from "node:path";
+import { parseFrontmatter, recordFromFrontmatter, recordFileName, serializeRecord } from "./frontmatter.js";
+import { atomicWriteFile, ensureDir, normalizeNewlines, pathExists, readJson, writeJson } from "./util.js";
+export class Store {
+    home;
+    seqCache = null;
+    shardSeqCache = null;
+    constructor(home) {
+        this.home = home;
+    }
+    path(...parts) {
+        return join(this.home, ...parts);
+    }
+    get memoriesDir() {
+        return this.path("memories");
+    }
+    get stateDir() {
+        return this.path("state");
+    }
+    get indexPath() {
+        return this.path("index");
+    }
+    get trashDir() {
+        return this.path("trash");
+    }
+    async init() {
+        await Promise.all([
+            ensureDir(this.path("memories", "user")),
+            ensureDir(this.path("memories", "projects")),
+            ensureDir(this.stateDir),
+            ensureDir(this.indexPath),
+            ensureDir(this.trashDir),
+            ensureDir(this.path("digests")),
+            ensureDir(this.path("sessions")),
+            ensureDir(this.path("prompts")),
+            ensureDir(this.path("data")),
+        ]);
+        if (!(await pathExists(this.path("VERSION")))) {
+            await atomicWriteFile(this.path("VERSION"), "1\n");
+        }
+    }
+    shardRef(scope, projectId) {
+        if (scope === "user")
+            return { scope, name: "user" };
+        if (!projectId)
+            throw new Error("project scope requires a projectId");
+        return { scope, project: projectId, name: projectId };
+    }
+    shardDir(shard) {
+        return shard.scope === "user"
+            ? this.path("memories", "user")
+            : this.path("memories", "projects", shard.project);
+    }
+    indexFile(shard) {
+        return join(this.shardDir(shard), "MEMORY.md");
+    }
+    digestDir(shard) {
+        return this.path("digests", shard.name);
+    }
+    recordPath(shard, id) {
+        return join(this.shardDir(shard), recordFileName(id));
+    }
+    async listShards() {
+        const out = [];
+        if (await pathExists(this.path("memories", "user")))
+            out.push({ scope: "user", name: "user" });
+        const projectsDir = this.path("memories", "projects");
+        if (await pathExists(projectsDir)) {
+            for (const entry of await fs.readdir(projectsDir, { withFileTypes: true })) {
+                if (!entry.isDirectory())
+                    continue;
+                out.push({ scope: "project", project: entry.name, name: entry.name });
+            }
+        }
+        return out;
+    }
+    /** Read every `.md` file in a shard (excluding MEMORY.md). */
+    async readShard(shard) {
+        const dir = this.shardDir(shard);
+        const records = [];
+        const errors = [];
+        let files = [];
+        try {
+            files = await fs.readdir(dir);
+        }
+        catch {
+            return { shard, records, errors };
+        }
+        for (const file of files) {
+            if (!file.endsWith(".md") || file === "MEMORY.md")
+                continue;
+            const full = join(dir, file);
+            try {
+                const raw = await fs.readFile(full, "utf8");
+                const parsed = parseFrontmatter(raw);
+                const fallbackId = basename(file, ".md");
+                const record = recordFromFrontmatter(parsed.data, parsed.body, fallbackId, 0);
+                record.id = record.id || fallbackId;
+                if (parsed.errors.length > 0)
+                    errors.push({ file: full, message: parsed.errors.join("; ") });
+                records.push(record);
+            }
+            catch (error) {
+                errors.push({ file: full, message: error.message });
+            }
+        }
+        records.sort((a, b) => a.created - b.created || a.id.localeCompare(b.id));
+        return { shard, records, errors };
+    }
+    async readRecord(shard, id) {
+        const file = this.recordPath(shard, id);
+        try {
+            const raw = await fs.readFile(file, "utf8");
+            const parsed = parseFrontmatter(raw);
+            const record = recordFromFrontmatter(parsed.data, parsed.body, id, 0);
+            record.id = record.id || id;
+            return record;
+        }
+        catch {
+            return null;
+        }
+    }
+    /** Find a record by id across all shards (cheap scan; ids are unique). */
+    async findRecord(id) {
+        for (const shard of await this.listShards()) {
+            const record = await this.readRecord(shard, id);
+            if (record)
+                return { record, shard };
+        }
+        return null;
+    }
+    async writeRecord(shard, record) {
+        await ensureDir(this.shardDir(shard));
+        await atomicWriteFile(this.recordPath(shard, record.id), serializeRecord(record));
+        await this.upsertIndexLine(shard, record);
+        await this.bumpSeq(shard.name);
+    }
+    /** Bulk write (import/migration): files first, index once, seq once. */
+    async writeRecordsBulk(shard, records) {
+        if (records.length === 0)
+            return;
+        await ensureDir(this.shardDir(shard));
+        const CONCURRENCY = 32;
+        for (let i = 0; i < records.length; i += CONCURRENCY) {
+            const batch = records.slice(i, i + CONCURRENCY);
+            await Promise.all(batch.map((record) => atomicWriteFile(this.recordPath(shard, record.id), serializeRecord(record))));
+        }
+        await this.rebuildIndexFile(shard);
+        await this.bumpSeq(shard.name);
+    }
+    /** Update MEMORY.md one line at a time (index is derived, safe to rebuild). */
+    async upsertIndexLine(shard, record) {
+        const file = this.indexFile(shard);
+        let lines = [];
+        try {
+            const raw = await fs.readFile(file, "utf8");
+            lines = normalizeNewlines(raw).split("\n");
+        }
+        catch {
+            lines = ["# Memory Index", "", "<!-- derived file, regenerated by `harnmem doctor --rebuild-index`; do not edit by hand -->", ""];
+        }
+        const { indexLine } = await import("./frontmatter.js");
+        const line = indexLine(record);
+        const needle = `(${recordFileName(record.id)})`;
+        const idx = lines.findIndex((l) => l.includes(needle));
+        if (idx >= 0) {
+            if (record.status === "dropped" || record.status === "archived")
+                lines.splice(idx, 1);
+            else
+                lines[idx] = line;
+        }
+        else if (record.status === "active") {
+            const headerEnd = Math.max(0, lines.findIndex((l) => l.startsWith("<!--")) + 1);
+            lines.splice(headerEnd, 0, line);
+        }
+        else {
+            return;
+        }
+        await atomicWriteFile(file, `${lines.join("\n").replace(/\n+$/, "")}\n`);
+    }
+    /** Move a record file to trash (soft delete for `forget`). */
+    async moveToTrash(shard, record, now) {
+        const src = this.recordPath(shard, record.id);
+        const dest = join(this.trashDir, `${dayStamp(now)}-${record.id}.md`);
+        await ensureDir(this.trashDir);
+        try {
+            await fs.rename(src, dest);
+        }
+        catch {
+            await fs.copyFile(src, dest);
+            await fs.unlink(src);
+        }
+        await this.upsertIndexLine(shard, { ...record, status: "dropped" });
+        await this.bumpSeq(shard.name);
+        return dest;
+    }
+    async getSeq() {
+        if (this.seqCache !== null)
+            return this.seqCache;
+        return this.peekSeq();
+    }
+    /**
+     * Per-shard sequence: index validity is checked against it, so a write to one
+     * project never invalidates unrelated shard indexes (global seq invalidates all).
+     */
+    async getShardSeq(name) {
+        if (this.seqCache === null || this.shardSeqCache === null)
+            await this.peekSeq();
+        return this.shardSeqCache?.get(name) ?? 0;
+    }
+    /** Read the seq from disk, bypassing the in-process cache (cross-process freshness). */
+    async peekSeq() {
+        const parsed = await readJson(this.path("state", "seq.json"), {
+            seq: 0,
+        });
+        const seq = typeof parsed.seq === "number" ? parsed.seq : 0;
+        this.seqCache = seq;
+        this.shardSeqCache = new Map(Object.entries(parsed.shards ?? {}));
+        return seq;
+    }
+    async bumpSeq(shardName) {
+        if (this.seqCache === null)
+            await this.peekSeq();
+        const next = (this.seqCache ?? 0) + 1;
+        this.seqCache = next;
+        if (shardName) {
+            const current = this.shardSeqCache?.get(shardName) ?? 0;
+            this.shardSeqCache?.set(shardName, current + 1);
+        }
+        const shards = this.shardSeqCache ? Object.fromEntries(this.shardSeqCache) : {};
+        await writeJson(this.path("state", "seq.json"), { seq: next, shards });
+        return next;
+    }
+    async audit(entry) {
+        const seq = entry.seq ?? (await this.getSeq());
+        const line = JSON.stringify({ seq, ...entry });
+        await ensureDir(this.stateDir);
+        const file = this.path("state", "audit.jsonl");
+        if (!(await pathExists(file))) {
+            await atomicWriteFile(file, `${line}\n`);
+            return;
+        }
+        const current = await fs.readFile(file, "utf8");
+        await atomicWriteFile(file, `${current.replace(/\n+$/, "")}\n${line}\n`);
+    }
+    async getCursor(key) {
+        const cursors = await readJson(this.path("state", "cursors.json"), {});
+        return cursors[key] ?? null;
+    }
+    async setCursor(key, value) {
+        const cursors = await readJson(this.path("state", "cursors.json"), {});
+        cursors[key] = value;
+        await writeJson(this.path("state", "cursors.json"), cursors);
+    }
+    usageCache = null;
+    /**
+     * Usage counters live in `state/usage.json`, not in the memory files: a search
+     * touches up to `budget` records, and rewriting N markdown files per query
+     * (plus invalidating every shard index) does not scale. Memory files stay the
+     * SSOT for content; `doctor --merge-usage` folds these counters back into the
+     * frontmatter when it matters.
+     */
+    async loadUsage() {
+        if (this.usageCache)
+            return this.usageCache;
+        const raw = await readJson(this.path("state", "usage.json"), {});
+        this.usageCache = new Map(Object.entries(raw));
+        return this.usageCache;
+    }
+    /** Persist usage counters (lastUsed/usedCount) touched by searches. */
+    async saveUsage(updates) {
+        if (updates.size === 0)
+            return;
+        const usage = await this.loadUsage();
+        for (const [id, update] of updates)
+            usage.set(id, update);
+        await writeJson(this.path("state", "usage.json"), Object.fromEntries(usage));
+    }
+    /**
+     * Session journal entry (only what extraction needs).
+     *
+     * Idempotent per message: re-persisting a snapshot that already covers
+     * messages from an earlier process (the adapter rehydrates its digest from
+     * this journal) appends only the lines that are not already present.
+     */
+    async appendSession(input) {
+        const date = input.date ?? dayStamp(Date.now());
+        const dir = this.path("sessions", date);
+        await ensureDir(dir);
+        const file = join(dir, `${input.harness}_${sanitizeFilePart(input.sessionId)}.jsonl`);
+        const existing = (await pathExists(file)) ? await fs.readFile(file, "utf8") : "";
+        const seen = new Set();
+        for (const rawLine of existing.split(/\r?\n/)) {
+            // Tolerate a UTF-8 BOM from hand-edited / PowerShell-written journals.
+            const line = rawLine.replace(/^\uFEFF/, "");
+            if (!line.trim())
+                continue;
+            try {
+                const parsed = JSON.parse(line);
+                if (parsed.role && typeof parsed.text === "string") {
+                    seen.add(journalKey(parsed.ts, parsed.role, parsed.text));
+                }
+            }
+            catch {
+                // Ignore malformed journal lines; new messages are still appended.
+            }
+        }
+        const fresh = [];
+        for (const m of input.messages) {
+            const ts = m.ts ?? Date.now();
+            const key = journalKey(ts, m.role, m.text);
+            if (seen.has(key))
+                continue;
+            seen.add(key);
+            fresh.push(JSON.stringify({ ts, role: m.role, text: m.text.slice(0, 4096), cwd: input.cwd }));
+        }
+        if (fresh.length === 0)
+            return;
+        await atomicWriteFile(file, `${existing}${fresh.join("\n")}\n`);
+    }
+    /**
+     * Read one session's persisted journal across day directories, oldest first,
+     * deduplicated and bounded to the last 200 messages.
+     *
+     * DSH resumes a session in a new process without replaying earlier events, so
+     * an adapter that only kept a process-local digest would always hit the
+     * `too_few_messages` gate at the next quit. Adapters use this to rehydrate.
+     */
+    async readSessionTranscript(harness, sessionId) {
+        const root = this.path("sessions");
+        let dates = [];
+        try {
+            dates = (await fs.readdir(root)).filter((name) => /^\d{8}$/.test(name)).sort();
+        }
+        catch {
+            return [];
+        }
+        const file = `${harness}_${sanitizeFilePart(sessionId)}.jsonl`;
+        const seen = new Set();
+        const out = [];
+        for (const date of dates) {
+            const path = join(root, date, file);
+            if (!(await pathExists(path)))
+                continue;
+            let raw = "";
+            try {
+                raw = await fs.readFile(path, "utf8");
+            }
+            catch {
+                continue;
+            }
+            for (const rawLine of raw.split(/\r?\n/)) {
+                // Tolerate a UTF-8 BOM from hand-edited / PowerShell-written journals.
+                const line = rawLine.replace(/^\uFEFF/, "");
+                if (!line.trim())
+                    continue;
+                try {
+                    const parsed = JSON.parse(line);
+                    if (typeof parsed.text !== "string" || parsed.text.trim() === "")
+                        continue;
+                    const role = parsed.role;
+                    if (role !== "user" && role !== "assistant" && role !== "tool" && role !== "system")
+                        continue;
+                    const key = journalKey(parsed.ts, role, parsed.text);
+                    if (seen.has(key))
+                        continue;
+                    seen.add(key);
+                    const message = { role, text: parsed.text };
+                    if (typeof parsed.ts === "number")
+                        message.ts = parsed.ts;
+                    out.push(message);
+                }
+                catch {
+                    // Ignore malformed journal lines.
+                }
+            }
+        }
+        out.sort((a, b) => (a.ts ?? 0) - (b.ts ?? 0));
+        return out.slice(-200);
+    }
+    async listDigests(shard) {
+        const dir = this.digestDir(shard);
+        let files = [];
+        try {
+            files = (await fs.readdir(dir)).filter((f) => f.endsWith(".md"));
+        }
+        catch {
+            return [];
+        }
+        const out = [];
+        for (const file of files) {
+            try {
+                const raw = await fs.readFile(join(dir, file), "utf8");
+                const parsed = parseFrontmatter(raw);
+                const firstHeading = parsed.body.split("\n").find((l) => l.trim().startsWith("#"));
+                out.push({
+                    name: file.replace(/\.md$/, ""),
+                    title: firstHeading ? firstHeading.replace(/^#+\s*/, "").trim() : file.replace(/\.md$/, ""),
+                    body: parsed.body.trim(),
+                    updated: typeof parsed.data["updated"] === "number" ? parsed.data["updated"] : undefined,
+                });
+            }
+            catch {
+                // skip unreadable digest
+            }
+        }
+        out.sort((a, b) => a.name.localeCompare(b.name));
+        return out;
+    }
+    /** Load/save per-shard search index JSON. */
+    async loadIndex(name) {
+        const file = this.path("index", `${sanitizeFilePart(name)}.json`);
+        if (!(await pathExists(file)))
+            return null;
+        return readJson(file, null);
+    }
+    async saveIndex(name, value) {
+        await writeJson(this.path("index", `${sanitizeFilePart(name)}.json`), value);
+    }
+    async readManifest() {
+        return readJson(this.path("index", "manifest.json"), null);
+    }
+    async writeManifest(seq, shards) {
+        await writeJson(this.path("index", "manifest.json"), { version: 1, seq, builtAt: Date.now(), shards });
+    }
+    /** Rebuild human-readable MEMORY.md for a shard from its files. */
+    async rebuildIndexFile(shard) {
+        const { records } = await this.readShard(shard);
+        const { indexLine } = await import("./frontmatter.js");
+        const active = records
+            .filter((r) => r.status === "active")
+            .sort((a, b) => (Number(b.pinned) - Number(a.pinned)) || b.updated - a.updated || a.id.localeCompare(b.id));
+        const lines = [
+            "# Memory Index",
+            "",
+            "<!-- derived file, regenerated by `harnmem doctor --rebuild-index`; do not edit by hand -->",
+            "",
+            ...active.map((r) => indexLine(r)),
+        ];
+        await atomicWriteFile(this.indexFile(shard), `${lines.join("\n")}\n`);
+        return active.length;
+    }
+    async stats() {
+        let user = 0;
+        let archived = 0;
+        let superseded = 0;
+        const projects = {};
+        for (const shard of await this.listShards()) {
+            const { records } = await this.readShard(shard);
+            const active = records.filter((r) => r.status === "active").length;
+            if (shard.scope === "user")
+                user = active;
+            else
+                projects[shard.project] = active;
+            archived += records.filter((r) => r.status === "archived").length;
+            superseded += records.filter((r) => r.status === "superseded").length;
+        }
+        let trash = 0;
+        try {
+            trash = (await fs.readdir(this.trashDir)).filter((f) => f.endsWith(".md")).length;
+        }
+        catch {
+            trash = 0;
+        }
+        let digests = 0;
+        for (const shard of await this.listShards())
+            digests += (await this.listDigests(shard)).length;
+        return {
+            memories: user + Object.values(projects).reduce((a, b) => a + b, 0),
+            user,
+            projects,
+            archived,
+            superseded,
+            trash,
+            digests,
+        };
+    }
+}
+function sanitizeFilePart(input) {
+    return input.replace(/[^A-Za-z0-9_.-]+/g, "_").slice(0, 80) || "x";
+}
+/** Identity of a journal message: same ts+role+text = same append. */
+function journalKey(ts, role, text) {
+    return `${ts ?? 0}\u0000${role}\u0000${text.slice(0, 200)}`;
+}
+function dayStamp(ts) {
+    const d = new Date(ts);
+    return `${d.getFullYear()}${`${d.getMonth() + 1}`.padStart(2, "0")}${`${d.getDate()}`.padStart(2, "0")}`;
+}
+export function shardKey(shard) {
+    return shard.name;
+}
+export function shardFromName(name) {
+    return name === "user" ? { scope: "user", name: "user" } : { scope: "project", project: name, name };
+}
+export { dirname };
+//# sourceMappingURL=store.js.map