@psiclawops/hypermem 0.1.0

package/dist/knowledge-graph.d.ts

@@ -0,0 +1,110 @@
+/**
+ * HyperMem Knowledge Graph
+ *
+ * DAG traversal over knowledge_links in library.db.
+ * Links connect entities across collections:
+ *   - fact ↔ fact (supersedes, contradicts, supports)
+ *   - fact ↔ knowledge (references, derived_from)
+ *   - knowledge ↔ knowledge (depends_on, extends)
+ *   - topic ↔ fact (covers)
+ *   - agent ↔ fact (authored_by)
+ *
+ * Traversal is bounded (max depth, max results) to prevent runaway queries.
+ */
+import type { DatabaseSync } from 'node:sqlite';
+export type EntityType = 'fact' | 'knowledge' | 'topic' | 'episode' | 'agent' | 'preference';
+export interface KnowledgeLink {
+    id: number;
+    fromType: EntityType;
+    fromId: number;
+    toType: EntityType;
+    toId: number;
+    linkType: string;
+    createdAt: string;
+}
+export interface GraphNode {
+    type: EntityType;
+    id: number;
+    depth: number;
+    linkType: string;
+    direction: 'outbound' | 'inbound';
+}
+export interface TraversalResult {
+    nodes: GraphNode[];
+    edges: KnowledgeLink[];
+    truncated: boolean;
+}
+export declare class KnowledgeGraph {
+    private readonly db;
+    constructor(db: DatabaseSync);
+    /**
+     * Create a directed link between two entities.
+     * Idempotent — unique constraint on (from_type, from_id, to_type, to_id, link_type).
+     */
+    addLink(fromType: EntityType, fromId: number, toType: EntityType, toId: number, linkType: string): KnowledgeLink;
+    /**
+     * Remove a specific link.
+     */
+    removeLink(fromType: EntityType, fromId: number, toType: EntityType, toId: number, linkType: string): boolean;
+    /**
+     * Remove all links involving an entity (both directions).
+     */
+    removeEntityLinks(type: EntityType, id: number): number;
+    /**
+     * Get outbound links from an entity.
+     */
+    getOutbound(type: EntityType, id: number, linkType?: string): KnowledgeLink[];
+    /**
+     * Get inbound links to an entity.
+     */
+    getInbound(type: EntityType, id: number, linkType?: string): KnowledgeLink[];
+    /**
+     * Get all links for an entity (both directions).
+     */
+    getLinks(type: EntityType, id: number): KnowledgeLink[];
+    /**
+     * Breadth-first traversal from a starting entity.
+     * Follows links in both directions up to maxDepth.
+     *
+     * @param startType - Entity type to start from
+     * @param startId - Entity ID to start from
+     * @param opts - Traversal options
+     * @returns Discovered nodes and edges
+     */
+    traverse(startType: EntityType, startId: number, opts?: {
+        maxDepth?: number;
+        maxResults?: number;
+        linkTypes?: string[];
+        direction?: 'outbound' | 'inbound' | 'both';
+        targetTypes?: EntityType[];
+    }): TraversalResult;
+    /**
+     * Find the shortest path between two entities.
+     * Uses BFS — returns null if no path exists within maxDepth.
+     */
+    findPath(fromType: EntityType, fromId: number, toType: EntityType, toId: number, maxDepth?: number): GraphNode[] | null;
+    /**
+     * Get the most connected entities (highest degree).
+     */
+    getMostConnected(opts?: {
+        type?: EntityType;
+        limit?: number;
+    }): Array<{
+        type: EntityType;
+        id: number;
+        degree: number;
+    }>;
+    /**
+     * Count links by type.
+     */
+    getLinkStats(): Array<{
+        linkType: string;
+        count: number;
+    }>;
+    /**
+     * Total link count.
+     */
+    getTotalLinks(): number;
+    private rowToLink;
+}
+//# sourceMappingURL=knowledge-graph.d.ts.map

package/dist/knowledge-graph.d.ts.map

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

package/dist/knowledge-graph.js

@@ -0,0 +1,305 @@
+/**
+ * HyperMem Knowledge Graph
+ *
+ * DAG traversal over knowledge_links in library.db.
+ * Links connect entities across collections:
+ *   - fact ↔ fact (supersedes, contradicts, supports)
+ *   - fact ↔ knowledge (references, derived_from)
+ *   - knowledge ↔ knowledge (depends_on, extends)
+ *   - topic ↔ fact (covers)
+ *   - agent ↔ fact (authored_by)
+ *
+ * Traversal is bounded (max depth, max results) to prevent runaway queries.
+ */
+function nowIso() {
+    return new Date().toISOString();
+}
+export class KnowledgeGraph {
+    db;
+    constructor(db) {
+        this.db = db;
+    }
+    // ─── Link Management ───────────────────────────────────────
+    /**
+     * Create a directed link between two entities.
+     * Idempotent — unique constraint on (from_type, from_id, to_type, to_id, link_type).
+     */
+    addLink(fromType, fromId, toType, toId, linkType) {
+        const now = nowIso();
+        this.db.prepare(`
+      INSERT OR IGNORE INTO knowledge_links (from_type, from_id, to_type, to_id, link_type, created_at)
+      VALUES (?, ?, ?, ?, ?, ?)
+    `).run(fromType, fromId, toType, toId, linkType, now);
+        const row = this.db.prepare(`
+      SELECT * FROM knowledge_links
+      WHERE from_type = ? AND from_id = ? AND to_type = ? AND to_id = ? AND link_type = ?
+    `).get(fromType, fromId, toType, toId, linkType);
+        return this.rowToLink(row);
+    }
+    /**
+     * Remove a specific link.
+     */
+    removeLink(fromType, fromId, toType, toId, linkType) {
+        const result = this.db.prepare(`
+      DELETE FROM knowledge_links
+      WHERE from_type = ? AND from_id = ? AND to_type = ? AND to_id = ? AND link_type = ?
+    `).run(fromType, fromId, toType, toId, linkType);
+        return result.changes > 0;
+    }
+    /**
+     * Remove all links involving an entity (both directions).
+     */
+    removeEntityLinks(type, id) {
+        const r1 = this.db.prepare('DELETE FROM knowledge_links WHERE from_type = ? AND from_id = ?').run(type, id);
+        const r2 = this.db.prepare('DELETE FROM knowledge_links WHERE to_type = ? AND to_id = ?').run(type, id);
+        return r1.changes + r2.changes;
+    }
+    // ─── Direct Queries ────────────────────────────────────────
+    /**
+     * Get outbound links from an entity.
+     */
+    getOutbound(type, id, linkType) {
+        if (linkType) {
+            return this.db.prepare('SELECT * FROM knowledge_links WHERE from_type = ? AND from_id = ? AND link_type = ?').all(type, id, linkType).map(r => this.rowToLink(r));
+        }
+        return this.db.prepare('SELECT * FROM knowledge_links WHERE from_type = ? AND from_id = ?').all(type, id).map(r => this.rowToLink(r));
+    }
+    /**
+     * Get inbound links to an entity.
+     */
+    getInbound(type, id, linkType) {
+        if (linkType) {
+            return this.db.prepare('SELECT * FROM knowledge_links WHERE to_type = ? AND to_id = ? AND link_type = ?').all(type, id, linkType).map(r => this.rowToLink(r));
+        }
+        return this.db.prepare('SELECT * FROM knowledge_links WHERE to_type = ? AND to_id = ?').all(type, id).map(r => this.rowToLink(r));
+    }
+    /**
+     * Get all links for an entity (both directions).
+     */
+    getLinks(type, id) {
+        return this.db.prepare(`
+      SELECT * FROM knowledge_links
+      WHERE (from_type = ? AND from_id = ?) OR (to_type = ? AND to_id = ?)
+      ORDER BY created_at DESC
+    `).all(type, id, type, id).map(r => this.rowToLink(r));
+    }
+    // ─── Traversal ─────────────────────────────────────────────
+    /**
+     * Breadth-first traversal from a starting entity.
+     * Follows links in both directions up to maxDepth.
+     *
+     * @param startType - Entity type to start from
+     * @param startId - Entity ID to start from
+     * @param opts - Traversal options
+     * @returns Discovered nodes and edges
+     */
+    traverse(startType, startId, opts) {
+        const maxDepth = opts?.maxDepth ?? 3;
+        const maxResults = opts?.maxResults ?? 50;
+        const direction = opts?.direction ?? 'both';
+        const linkTypes = opts?.linkTypes;
+        const targetTypes = opts?.targetTypes;
+        const visited = new Set();
+        const nodes = [];
+        const edges = [];
+        let truncated = false;
+        // BFS queue: [type, id, depth]
+        const queue = [[startType, startId, 0]];
+        visited.add(`${startType}:${startId}`);
+        while (queue.length > 0 && nodes.length < maxResults) {
+            const [currentType, currentId, depth] = queue.shift();
+            if (depth >= maxDepth) {
+                if (depth > maxDepth)
+                    truncated = true;
+                continue;
+            }
+            // Get neighbors
+            const neighbors = [];
+            if (direction === 'outbound' || direction === 'both') {
+                const outbound = linkTypes
+                    ? this.getOutbound(currentType, currentId).filter(l => linkTypes.includes(l.linkType))
+                    : this.getOutbound(currentType, currentId);
+                for (const link of outbound) {
+                    const nodeType = link.toType;
+                    if (targetTypes && !targetTypes.includes(nodeType))
+                        continue;
+                    neighbors.push({
+                        node: {
+                            type: nodeType,
+                            id: link.toId,
+                            depth: depth + 1,
+                            linkType: link.linkType,
+                            direction: 'outbound',
+                        },
+                        link,
+                    });
+                }
+            }
+            if (direction === 'inbound' || direction === 'both') {
+                const inbound = linkTypes
+                    ? this.getInbound(currentType, currentId).filter(l => linkTypes.includes(l.linkType))
+                    : this.getInbound(currentType, currentId);
+                for (const link of inbound) {
+                    const nodeType = link.fromType;
+                    if (targetTypes && !targetTypes.includes(nodeType))
+                        continue;
+                    neighbors.push({
+                        node: {
+                            type: nodeType,
+                            id: link.fromId,
+                            depth: depth + 1,
+                            linkType: link.linkType,
+                            direction: 'inbound',
+                        },
+                        link,
+                    });
+                }
+            }
+            for (const { node, link } of neighbors) {
+                const key = `${node.type}:${node.id}`;
+                if (visited.has(key))
+                    continue;
+                visited.add(key);
+                if (nodes.length >= maxResults) {
+                    truncated = true;
+                    break;
+                }
+                nodes.push(node);
+                edges.push(link);
+                queue.push([node.type, node.id, node.depth]);
+            }
+        }
+        if (queue.length > 0)
+            truncated = true;
+        return { nodes, edges, truncated };
+    }
+    /**
+     * Find the shortest path between two entities.
+     * Uses BFS — returns null if no path exists within maxDepth.
+     */
+    findPath(fromType, fromId, toType, toId, maxDepth = 5) {
+        const visited = new Map();
+        const startKey = `${fromType}:${fromId}`;
+        const endKey = `${toType}:${toId}`;
+        visited.set(startKey, {
+            parent: null,
+            node: { type: fromType, id: fromId, depth: 0, linkType: 'start', direction: 'outbound' },
+        });
+        const queue = [[fromType, fromId, 0]];
+        while (queue.length > 0) {
+            const [currentType, currentId, depth] = queue.shift();
+            const currentKey = `${currentType}:${currentId}`;
+            if (currentKey === endKey) {
+                // Reconstruct path
+                const path = [];
+                let key = endKey;
+                while (key) {
+                    const entry = visited.get(key);
+                    if (!entry)
+                        break;
+                    path.unshift(entry.node);
+                    key = entry.parent;
+                }
+                return path;
+            }
+            if (depth >= maxDepth)
+                continue;
+            // Expand in both directions
+            const allLinks = this.getLinks(currentType, currentId);
+            for (const link of allLinks) {
+                let nextType;
+                let nextId;
+                let dir;
+                if (link.fromType === currentType && link.fromId === currentId) {
+                    nextType = link.toType;
+                    nextId = link.toId;
+                    dir = 'outbound';
+                }
+                else {
+                    nextType = link.fromType;
+                    nextId = link.fromId;
+                    dir = 'inbound';
+                }
+                const nextKey = `${nextType}:${nextId}`;
+                if (visited.has(nextKey))
+                    continue;
+                const node = {
+                    type: nextType,
+                    id: nextId,
+                    depth: depth + 1,
+                    linkType: link.linkType,
+                    direction: dir,
+                };
+                visited.set(nextKey, { parent: currentKey, node });
+                queue.push([nextType, nextId, depth + 1]);
+            }
+        }
+        return null; // No path found
+    }
+    // ─── Analytics ─────────────────────────────────────────────
+    /**
+     * Get the most connected entities (highest degree).
+     */
+    getMostConnected(opts) {
+        const limit = opts?.limit ?? 10;
+        const query = opts?.type
+            ? `
+        SELECT type, id, COUNT(*) as degree FROM (
+          SELECT from_type as type, from_id as id FROM knowledge_links WHERE from_type = ?
+          UNION ALL
+          SELECT to_type as type, to_id as id FROM knowledge_links WHERE to_type = ?
+        )
+        GROUP BY type, id
+        ORDER BY degree DESC
+        LIMIT ?
+      `
+            : `
+        SELECT type, id, COUNT(*) as degree FROM (
+          SELECT from_type as type, from_id as id FROM knowledge_links
+          UNION ALL
+          SELECT to_type as type, to_id as id FROM knowledge_links
+        )
+        GROUP BY type, id
+        ORDER BY degree DESC
+        LIMIT ?
+      `;
+        const rows = opts?.type
+            ? this.db.prepare(query).all(opts.type, opts.type, limit)
+            : this.db.prepare(query).all(limit);
+        return rows.map(r => ({
+            type: r.type,
+            id: r.id,
+            degree: r.degree,
+        }));
+    }
+    /**
+     * Count links by type.
+     */
+    getLinkStats() {
+        const rows = this.db.prepare('SELECT link_type, COUNT(*) as count FROM knowledge_links GROUP BY link_type ORDER BY count DESC').all();
+        return rows.map(r => ({
+            linkType: r.link_type,
+            count: r.count,
+        }));
+    }
+    /**
+     * Total link count.
+     */
+    getTotalLinks() {
+        const row = this.db.prepare('SELECT COUNT(*) as count FROM knowledge_links').get();
+        return row.count;
+    }
+    // ─── Helpers ───────────────────────────────────────────────
+    rowToLink(row) {
+        return {
+            id: row.id,
+            fromType: row.from_type,
+            fromId: row.from_id,
+            toType: row.to_type,
+            toId: row.to_id,
+            linkType: row.link_type,
+            createdAt: row.created_at,
+        };
+    }
+}
+//# sourceMappingURL=knowledge-graph.js.map

package/dist/knowledge-store.d.ts

@@ -0,0 +1,72 @@
+/**
+ * HyperMem Knowledge Store
+ *
+ * Long-term structured knowledge — replaces MEMORY.md.
+ * Lives in the central library DB.
+ * Knowledge entries are keyed (domain + key), versioned via superseded_by,
+ * and linked to each other via knowledge_links.
+ */
+import type { DatabaseSync } from 'node:sqlite';
+import type { Knowledge } from './types.js';
+export type LinkType = 'supports' | 'contradicts' | 'depends_on' | 'supersedes' | 'related';
+export declare class KnowledgeStore {
+    private readonly db;
+    constructor(db: DatabaseSync);
+    /**
+     * Upsert a knowledge entry.
+     *
+     * Versioning semantics:
+     * - If no active entry exists: insert as version 1
+     * - If same content: refresh confidence + timestamp only (no new version)
+     * - If different content: insert as new version (max_version + 1), mark
+     *   previous active row as superseded_by = new_id
+     *
+     * This guarantees version history is real rows, not in-place overwrites.
+     * The unique constraint is (agent_id, domain, key, version) so each
+     * version is a distinct row.
+     */
+    upsert(agentId: string, domain: string, key: string, content: string, opts?: {
+        confidence?: number;
+        visibility?: string;
+        sourceType?: string;
+        sourceRef?: string;
+        expiresAt?: string;
+    }): Knowledge;
+    /**
+     * Get current (non-superseded) knowledge for an agent.
+     */
+    getActive(agentId: string, opts?: {
+        domain?: string;
+        limit?: number;
+    }): Knowledge[];
+    /**
+     * Get a specific knowledge entry by domain + key.
+     */
+    get(agentId: string, domain: string, key: string): Knowledge | null;
+    /**
+     * Get the version history of a knowledge entry.
+     */
+    getHistory(agentId: string, domain: string, key: string): Knowledge[];
+    /**
+     * Search knowledge by content.
+     */
+    search(agentId: string, query: string, limit?: number): Knowledge[];
+    /**
+     * List all domains for an agent.
+     */
+    getDomains(agentId: string): string[];
+    /**
+     * Add a link between knowledge entries.
+     */
+    addLink(fromId: number, toId: number, linkType: LinkType): void;
+    /**
+     * Get knowledge count.
+     */
+    getCount(agentId: string): number;
+    /**
+     * Import from MEMORY.md content.
+     * Parses markdown sections into domain/key/content entries.
+     */
+    importFromMarkdown(agentId: string, markdown: string, sourcePath: string): number;
+}
+//# sourceMappingURL=knowledge-store.d.ts.map

package/dist/knowledge-store.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"knowledge-store.d.ts","sourceRoot":"","sources":["../src/knowledge-store.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAChD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,YAAY,CAAC;AAuB5C,MAAM,MAAM,QAAQ,GAAG,UAAU,GAAG,aAAa,GAAG,YAAY,GAAG,YAAY,GAAG,SAAS,CAAC;AAE5F,qBAAa,cAAc;IACb,OAAO,CAAC,QAAQ,CAAC,EAAE;gBAAF,EAAE,EAAE,YAAY;IAE7C;;;;;;;;;;;;OAYG;IACH,MAAM,CACJ,OAAO,EAAE,MAAM,EACf,MAAM,EAAE,MAAM,EACd,GAAG,EAAE,MAAM,EACX,OAAO,EAAE,MAAM,EACf,IAAI,CAAC,EAAE;QACL,UAAU,CAAC,EAAE,MAAM,CAAC;QACpB,UAAU,CAAC,EAAE,MAAM,CAAC;QACpB,UAAU,CAAC,EAAE,MAAM,CAAC;QACpB,SAAS,CAAC,EAAE,MAAM,CAAC;QACnB,SAAS,CAAC,EAAE,MAAM,CAAC;KACpB,GACA,SAAS;IAsEZ;;OAEG;IACH,SAAS,CACP,OAAO,EAAE,MAAM,EACf,IAAI,CAAC,EAAE;QACL,MAAM,CAAC,EAAE,MAAM,CAAC;QAChB,KAAK,CAAC,EAAE,MAAM,CAAC;KAChB,GACA,SAAS,EAAE;IAyBd;;OAEG;IACH,GAAG,CAAC,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,SAAS,GAAG,IAAI;IAUnE;;OAEG;IACH,UAAU,CAAC,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,SAAS,EAAE;IAUrE;;OAEG;IACH,MAAM,CAAC,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,KAAK,GAAE,MAAW,GAAG,SAAS,EAAE;IAavE;;OAEG;IACH,UAAU,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,EAAE;IAUrC;;OAEG;IACH,OAAO,CAAC,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,QAAQ,GAAG,IAAI;IAO/D;;OAEG;IACH,QAAQ,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM;IAOjC;;;OAGG;IACH,kBAAkB,CAAC,OAAO,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,GAAG,MAAM;CAwDlF"}