@openanonymity/nanomem 0.1.0

package/src/backends/indexeddb.js

@@ -0,0 +1,208 @@
+/**
+ * IndexedDBStorage — Virtual markdown filesystem backed by IndexedDB.
+ *
+ * Browser-only. Stores memory files in a separate 'oa-memory-fs' database.
+ */
+/** @import { ExportRecord, StorageMetadata } from '../types.js' */
+import { BaseStorage } from './BaseStorage.js';
+import { countBullets, extractTitles } from '../bullets/index.js';
+import { buildTree, createBootstrapRecords } from './schema.js';
+
+const DB_NAME = 'oa-memory-fs';
+const DB_VERSION = 1;
+const STORE_NAME = 'memoryFiles';
+
+class IndexedDBStorage extends BaseStorage {
+    constructor() {
+        super();
+        /** @type {IDBDatabase | null} */
+        this.db = null;
+        /** @type {Promise<IDBDatabase> | null} */
+        this._initPromise = null;
+    }
+
+    /** @returns {Promise<void>} */
+    async init() {
+        if (this.db) return;
+        if (this._initPromise) {
+            await this._initPromise;
+            return;
+        }
+
+        this._initPromise = /** @type {Promise<IDBDatabase>} */ (new Promise((resolve, reject) => {
+            const request = indexedDB.open(DB_NAME, DB_VERSION);
+
+            request.onupgradeneeded = (event) => {
+                const db = /** @type {IDBOpenDBRequest} */ (event.target).result;
+                if (!db.objectStoreNames.contains(STORE_NAME)) {
+                    const store = db.createObjectStore(STORE_NAME, { keyPath: 'path' });
+                    store.createIndex('parentPath', 'parentPath', { unique: false });
+                }
+            };
+
+            request.onsuccess = async (event) => {
+                this.db = /** @type {IDBOpenDBRequest} */ (event.target).result;
+                try { await this._bootstrap(); } catch (err) {
+                    console.warn('[IndexedDBStorage] Init error:', err);
+                }
+                resolve(/** @type {IDBDatabase} */ (this.db));
+            };
+
+            request.onerror = () => {
+                this._initPromise = null;
+                reject(request.error);
+            };
+        }));
+
+        await this._initPromise;
+    }
+
+    async _bootstrap() {
+        const all = await this._getAll();
+        if (all.length > 0) return;
+
+        const seeds = createBootstrapRecords(Date.now());
+        return /** @type {Promise<void>} */ (new Promise((resolve, reject) => {
+            const tx = /** @type {IDBDatabase} */ (this.db).transaction(STORE_NAME, 'readwrite');
+            const store = tx.objectStore(STORE_NAME);
+            for (const seed of seeds) store.put(seed);
+            tx.oncomplete = () => resolve();
+            tx.onerror = () => reject(tx.error);
+        }));
+    }
+
+    async _readRaw(path) {
+        await this.init();
+        return new Promise((resolve, reject) => {
+            const tx = /** @type {IDBDatabase} */ (this.db).transaction(STORE_NAME, 'readonly');
+            const request = tx.objectStore(STORE_NAME).get(path);
+            request.onsuccess = () => resolve(request.result?.content ?? null);
+            request.onerror = () => reject(request.error);
+        });
+    }
+
+    async _writeRaw(path, content, meta = {}) {
+        await this.init();
+        const now = Date.now();
+        const existing = await this._get(path);
+        const str = String(content || '');
+
+        const record = {
+            path,
+            content: str,
+            oneLiner: meta.oneLiner ?? this._generateOneLiner(str),
+            itemCount: meta.itemCount ?? countBullets(str),
+            titles: meta.titles ?? extractTitles(str),
+            parentPath: this._parentPath(path),
+            createdAt: existing?.createdAt ?? now,
+            updatedAt: now,
+        };
+
+        await /** @type {Promise<void>} */ (new Promise((resolve, reject) => {
+            const tx = /** @type {IDBDatabase} */ (this.db).transaction(STORE_NAME, 'readwrite');
+            const request = tx.objectStore(STORE_NAME).put(record);
+            request.onsuccess = () => resolve();
+            request.onerror = () => reject(request.error);
+        }));
+    }
+
+    /**
+     * @param {string} path
+     * @returns {Promise<void>}
+     */
+    async delete(path) {
+        if (this._isInternalPath(path)) return;
+        await this.init();
+
+        await /** @type {Promise<void>} */ (new Promise((resolve, reject) => {
+            const tx = /** @type {IDBDatabase} */ (this.db).transaction(STORE_NAME, 'readwrite');
+            const request = tx.objectStore(STORE_NAME).delete(path);
+            request.onsuccess = () => resolve();
+            request.onerror = () => reject(request.error);
+        }));
+        await this.rebuildTree();
+    }
+
+    /** @returns {Promise<void>} */
+    async clear() {
+        await this.init();
+        await /** @type {Promise<void>} */ (new Promise((resolve, reject) => {
+            const tx = /** @type {IDBDatabase} */ (this.db).transaction(STORE_NAME, 'readwrite');
+            const request = tx.objectStore(STORE_NAME).clear();
+            request.onsuccess = () => resolve();
+            request.onerror = () => reject(request.error);
+        }));
+        this._initPromise = null;
+        await this._bootstrap();
+    }
+
+    /**
+     * @param {string} path
+     * @returns {Promise<boolean>}
+     */
+    async exists(path) {
+        await this.init();
+        return new Promise((resolve, reject) => {
+            const tx = /** @type {IDBDatabase} */ (this.db).transaction(STORE_NAME, 'readonly');
+            const request = tx.objectStore(STORE_NAME).getKey(path);
+            request.onsuccess = () => resolve(request.result !== undefined);
+            request.onerror = () => reject(request.error);
+        });
+    }
+
+    /** @returns {Promise<void>} */
+    async rebuildTree() {
+        await this.init();
+        const all = await this._getAll();
+        const files = all
+            .filter((r) => !this._isInternalPath(r.path))
+            .sort((a, b) => a.path.localeCompare(b.path));
+        const indexContent = buildTree(files);
+        const existing = await this._get('_tree.md');
+        const now = Date.now();
+
+        await /** @type {Promise<void>} */ (new Promise((resolve, reject) => {
+            const tx = /** @type {IDBDatabase} */ (this.db).transaction(STORE_NAME, 'readwrite');
+            tx.objectStore(STORE_NAME).put({
+                path: '_tree.md',
+                content: indexContent,
+                oneLiner: 'Root index of memory filesystem',
+                itemCount: 0,
+                titles: [],
+                parentPath: '',
+                createdAt: existing?.createdAt ?? now,
+                updatedAt: now,
+            });
+            tx.oncomplete = () => resolve();
+            tx.onerror = () => reject(tx.error);
+        }));
+    }
+
+    /** @returns {Promise<ExportRecord[]>} */
+    async exportAll() {
+        await this.init();
+        return this._getAll();
+    }
+
+    // ─── Internal IndexedDB helpers ──────────────────────────────
+
+    async _get(path) {
+        return new Promise((resolve, reject) => {
+            const tx = /** @type {IDBDatabase} */ (this.db).transaction(STORE_NAME, 'readonly');
+            const request = tx.objectStore(STORE_NAME).get(path);
+            request.onsuccess = () => resolve(request.result ?? null);
+            request.onerror = () => reject(request.error);
+        });
+    }
+
+    async _getAll() {
+        return new Promise((resolve, reject) => {
+            const tx = /** @type {IDBDatabase} */ (this.db).transaction(STORE_NAME, 'readonly');
+            const request = tx.objectStore(STORE_NAME).getAll();
+            request.onsuccess = () => resolve(request.result || []);
+            request.onerror = () => reject(request.error);
+        });
+    }
+}
+
+export { IndexedDBStorage };

package/src/backends/ram.js

@@ -0,0 +1,113 @@
+/**
+ * InMemoryStorage — In-memory (RAM) storage backend for testing.
+ *
+ * Data is lost when the process exits.
+ */
+/** @import { ExportRecord, StorageMetadata } from '../types.js' */
+import { BaseStorage } from './BaseStorage.js';
+import { countBullets, extractTitles } from '../bullets/index.js';
+import { buildTree, createBootstrapRecords } from './schema.js';
+
+class InMemoryStorage extends BaseStorage {
+    constructor() {
+        super();
+        this._files = new Map();
+        this._initialized = false;
+    }
+
+    async init() {
+        if (this._initialized) return;
+        this._initialized = true;
+
+        if (this._files.size === 0) {
+            const seeds = createBootstrapRecords(Date.now());
+            for (const seed of seeds) {
+                this._files.set(seed.path, seed);
+            }
+        }
+
+    }
+
+    async _readRaw(path) {
+        await this.init();
+        return this._files.get(path)?.content ?? null;
+    }
+
+    async _writeRaw(path, content, meta = {}) {
+        await this.init();
+        const now = Date.now();
+        const existing = this._files.get(path);
+        const str = String(content || '');
+
+        this._files.set(path, {
+            path,
+            content: str,
+            oneLiner: meta.oneLiner ?? this._generateOneLiner(str),
+            itemCount: meta.itemCount ?? countBullets(str),
+            titles: meta.titles ?? extractTitles(str),
+            parentPath: this._parentPath(path),
+            createdAt: existing?.createdAt ?? now,
+            updatedAt: now,
+        });
+    }
+
+    /**
+     * @param {string} path
+     * @returns {Promise<void>}
+     */
+    async delete(path) {
+        if (this._isInternalPath(path)) return;
+        await this.init();
+        this._files.delete(path);
+        await this.rebuildTree();
+    }
+
+    async clear() {
+        this._files.clear();
+        this._initialized = false;
+        await this.init();
+    }
+
+    /**
+     * @param {string} path
+     * @returns {Promise<boolean>}
+     */
+    async exists(path) {
+        await this.init();
+        return this._files.has(path);
+    }
+
+    async rebuildTree() {
+        await this.init();
+        const files = [...this._files.values()]
+            .filter(r => !this._isInternalPath(r.path))
+            .sort((a, b) => a.path.localeCompare(b.path));
+        const indexContent = buildTree(files);
+        const existing = this._files.get('_tree.md');
+        const now = Date.now();
+
+        this._files.set('_tree.md', {
+            path: '_tree.md',
+            content: indexContent,
+            oneLiner: 'Root index of memory filesystem',
+            itemCount: 0,
+            titles: [],
+            parentPath: '',
+            createdAt: existing?.createdAt ?? now,
+            updatedAt: now,
+        });
+    }
+
+    /** @returns {Promise<ExportRecord[]>} */
+    async exportAll() {
+        await this.init();
+        return [...this._files.values()];
+    }
+
+    async _listAllPaths() {
+        await this.init();
+        return [...this._files.keys()].filter(p => !this._isInternalPath(p));
+    }
+}
+
+export { InMemoryStorage };

package/src/backends/schema.js

@@ -0,0 +1,42 @@
+/**
+ * Memory index generation and bootstrap.
+ */
+/** @import { ExportRecord } from '../types.js' */
+
+export function buildBootstrapIndex() {
+    return `# Memory Index\n\n_No memories yet._\n`;
+}
+
+export function createBootstrapRecords(now = Date.now()) {
+    return [
+        {
+            path: '_tree.md',
+            content: buildBootstrapIndex(),
+            oneLiner: 'Root index of memory filesystem',
+            parentPath: '',
+            createdAt: now,
+            updatedAt: now
+        }
+    ];
+}
+
+export function buildTree(files) {
+    const lines = ['# Memory Index', ''];
+
+    if (files.length > 0) {
+        for (const file of files) {
+            const count = file.itemCount || 0;
+            const updated = file.updatedAt
+                ? new Date(file.updatedAt).toISOString().split('T')[0]
+                : '';
+            const meta = count > 0
+                ? `(${count} item${count !== 1 ? 's' : ''}, updated ${updated})`
+                : updated ? `(updated ${updated})` : '';
+            lines.push(`- ${file.path} ${meta} — ${file.oneLiner}`);
+        }
+    } else {
+        lines.push('_No files yet._');
+    }
+
+    return lines.join('\n');
+}

package/src/bullets/bulletIndex.js

@@ -0,0 +1,125 @@
+/** @import { Bullet, BulletItem, StorageBackend } from '../types.js' */
+import { parseBullets, todayIsoDate } from './index.js';
+
+class MemoryBulletIndex {
+    /**
+     * @param {StorageBackend} backend
+     */
+    constructor(backend) {
+        this._backend = backend;
+        this._initialized = false;
+        this._initPromise = null;
+        this._pathToBullets = new Map();
+        this._pathToUpdatedAt = new Map();
+    }
+
+    /** @returns {Promise<void>} */
+    async init() {
+        if (this._initialized) return;
+        if (this._initPromise) return this._initPromise;
+
+        this._initPromise = this._rebuild();
+        await this._initPromise;
+    }
+
+    /** @returns {Promise<void>} */
+    async rebuild() {
+        this._initialized = false;
+        this._initPromise = this._rebuild();
+        await this._initPromise;
+    }
+
+    async _rebuild() {
+        await this._backend.init();
+        const all = await this._backend.exportAll();
+        this._pathToBullets.clear();
+        this._pathToUpdatedAt.clear();
+
+        for (const file of all) {
+            if (file.path.endsWith('_tree.md')) continue;
+            const bullets = this._parseForIndex(file.path, file.content || '');
+            this._pathToBullets.set(file.path, bullets);
+            this._pathToUpdatedAt.set(file.path, file.updatedAt || Date.now());
+        }
+
+        this._initialized = true;
+        this._initPromise = null;
+    }
+
+    _parseForIndex(path, content) {
+        const parsed = parseBullets(content || '');
+        if (parsed.length > 0) return parsed;
+
+        // Lightweight fallback for legacy files: use plain lines as bullets.
+        const lines = String(content || '')
+            .split('\n')
+            .map((line) => line.trim())
+            .filter(Boolean)
+            .filter((line) => !line.startsWith('#'))
+            .filter((line) => !/^_no entries yet\._$/i.test(line))
+            .slice(0, 200);
+
+        const today = todayIsoDate();
+        return lines.map((line) => ({
+            text: line,
+            topic: path.split('/')[0] || 'general',
+            updatedAt: today,
+            expiresAt: null,
+            reviewAt: null,
+            tier: 'long_term',
+            status: 'active',
+            source: null,
+            confidence: null,
+            explicitTier: false,
+            explicitStatus: false,
+            explicitSource: false,
+            explicitConfidence: false,
+            heading: 'General',
+            section: 'long_term',
+            lineIndex: 0
+        }));
+    }
+
+    /**
+     * @param {string} path
+     * @returns {Promise<void>}
+     */
+    async refreshPath(path) {
+        await this.init();
+        if (!path || path.endsWith('_tree.md')) return;
+
+        const content = await this._backend.read(path);
+        if (content === null) {
+            this._pathToBullets.delete(path);
+            this._pathToUpdatedAt.delete(path);
+            return;
+        }
+
+        const bullets = this._parseForIndex(path, content);
+        this._pathToBullets.set(path, bullets);
+        this._pathToUpdatedAt.set(path, Date.now());
+    }
+
+    /**
+     * @param {string[]} paths
+     * @returns {BulletItem[]}
+     */
+    getBulletsForPaths(paths) {
+        if (!this._initialized) return [];
+        const items = [];
+        for (const path of paths || []) {
+            const bullets = this._pathToBullets.get(path);
+            if (!bullets || bullets.length === 0) continue;
+            for (const bullet of bullets) {
+                items.push({
+                    path,
+                    bullet,
+                    fileUpdatedAt: this._pathToUpdatedAt.get(path) || 0
+                });
+            }
+        }
+        return items;
+    }
+}
+
+export { MemoryBulletIndex };

package/src/bullets/compaction.js

@@ -0,0 +1,109 @@
+/**
+ * Bullet compaction — deduplication, tier assignment, strength-based ordering.
+ *
+ * Strength ordering uses source > confidence > recency:
+ *   user_statement > assistant_summary > system > inference
+ *   high > medium > low
+ *   newer > older
+ */
+/** @import { Bullet, CompactionResult, CompactBulletsOptions, Confidence, Source } from '../types.js' */
+import {
+    ensureBulletMetadata,
+    normalizeFactText,
+    normalizeTier,
+    normalizeStatus,
+    normalizeSource,
+    normalizeConfidence,
+    normalizeTierToSection,
+    inferStatusFromSection,
+    isExpiredBullet,
+    todayIsoDate,
+    normalizeTopic,
+    defaultConfidenceForSource,
+} from './normalize.js';
+
+/**
+ * Compact a list of bullets: deduplicate, assign tiers, enforce limits.
+ * @param {Bullet[]} bullets
+ * @param {CompactBulletsOptions} [options]
+ * @returns {CompactionResult}
+ */
+export function compactBullets(bullets, options = {}) {
+    const today = options.today || todayIsoDate();
+    const maxActivePerTopic = typeof options.maxActivePerTopic === 'number' && Number.isFinite(options.maxActivePerTopic)
+        ? Math.max(1, options.maxActivePerTopic)
+        : 24;
+    const defaultTopic = normalizeTopic(options.defaultTopic || 'general');
+
+    // Deduplicate by normalized text — keep the stronger/newer variant.
+    const dedup = new Map();
+    for (const original of bullets) {
+        const normalized = ensureBulletMetadata(original, { defaultTopic, updatedAt: today });
+        const key = normalizeFactText(normalized.text);
+        if (!key) continue;
+        const existing = dedup.get(key);
+        if (!existing || compareBulletStrength(normalized, existing) >= 0) {
+            dedup.set(key, normalized);
+        }
+    }
+
+    const working = [];
+    const longTerm = [];
+    const history = [];
+
+    // Group by topic, separate expired/superseded upfront.
+    const byTopic = new Map();
+    for (const bullet of dedup.values()) {
+        const tier = normalizeTier(bullet.tier || bullet.section || 'long_term');
+        const status = normalizeStatus(bullet.status || inferStatusFromSection(normalizeTierToSection(tier)));
+
+        if (tier === 'history' || status === 'superseded' || status === 'expired' || isExpiredBullet(bullet, today)) {
+            history.push({ ...bullet, tier: 'history', status: status === 'active' ? 'superseded' : status, section: 'history' });
+            continue;
+        }
+
+        const topic = bullet.topic || defaultTopic;
+        const list = byTopic.get(topic) || [];
+        list.push({ ...bullet, topic, tier, status, section: normalizeTierToSection(tier) });
+        byTopic.set(topic, list);
+    }
+
+    // Sort by strength, enforce per-topic limit, overflow to history.
+    for (const [topic, list] of byTopic.entries()) {
+        list.sort((a, b) => compareBulletStrength(b, a));
+        for (const item of list.slice(0, maxActivePerTopic)) {
+            if (item.tier === 'working') {
+                working.push({ ...item, topic, tier: 'working', status: item.status || 'active', section: 'working' });
+            } else {
+                longTerm.push({ ...item, topic, tier: 'long_term', status: item.status || 'active', section: 'long_term' });
+            }
+        }
+        for (const item of list.slice(maxActivePerTopic)) {
+            history.push({ ...item, topic, tier: 'history', status: 'superseded', section: 'history' });
+        }
+    }
+
+    const byRecency = (a, b) => (b.updatedAt || '').localeCompare(a.updatedAt || '');
+    working.sort(byRecency);
+    longTerm.sort(byRecency);
+    history.sort(byRecency);
+
+    return { working, longTerm, history, active: [...working, ...longTerm], archive: history };
+}
+
+function compareBulletStrength(a, b) {
+    const aSource = normalizeSource(a?.source, 'user_statement');
+    const bSource = normalizeSource(b?.source, 'user_statement');
+    const aConf = normalizeConfidence(a?.confidence, defaultConfidenceForSource(aSource));
+    const bConf = normalizeConfidence(b?.confidence, defaultConfidenceForSource(bSource));
+
+    const srcRank = { inference: 0, system: 1, assistant_summary: 2, user_statement: 3 };
+    const srcDiff = (srcRank[aSource] ?? 0) - (srcRank[bSource] ?? 0);
+    if (srcDiff !== 0) return srcDiff;
+
+    const confRank = { low: 0, medium: 1, high: 2 };
+    const confDiff = (confRank[aConf] ?? 1) - (confRank[bConf] ?? 1);
+    if (confDiff !== 0) return confDiff;
+
+    return String(a?.updatedAt || '').localeCompare(String(b?.updatedAt || ''));
+}

package/src/bullets/index.js

@@ -0,0 +1,16 @@
+/**
+ * Barrel re-export for all bullet utilities.
+ *
+ * @typedef {import('../types.js').Tier} Tier
+ * @typedef {import('../types.js').Status} Status
+ * @typedef {import('../types.js').Source} Source
+ * @typedef {import('../types.js').Confidence} Confidence
+ * @typedef {import('../types.js').Bullet} Bullet
+ * @typedef {import('../types.js').EnsureBulletMetadataOptions} EnsureBulletMetadataOptions
+ * @typedef {import('../types.js').CompactionResult} CompactionResult
+ * @typedef {import('../types.js').CompactBulletsOptions} CompactBulletsOptions
+ */
+export * from './normalize.js';
+export * from './parser.js';
+export * from './scoring.js';
+export * from './compaction.js';