learngraph 0.1.1 → 0.3.0

package/dist/esm/storage/levelgraph.js

@@ -0,0 +1,818 @@
+/**
+ * LevelGraph storage adapter
+ *
+ * Browser-compatible graph storage using LevelGraph (triple store)
+ * built on LevelDB/IndexedDB.
+ *
+ * @packageDocumentation
+ */
+import { GRAPH_VERSION, createSkillId, createEdgeId } from '../types/index.js';
+import { NotFoundError, DuplicateError, ReferenceError as StorageReferenceError, ConnectionError, } from './errors.js';
+import { nowISO, inputToSkillNode, inputToEdge, validateSkillInput, validateEdgeInput, requireConnection, calculateStats, } from './base.js';
+/**
+ * Skill property predicates for triple mapping
+ */
+const SKILL_PREDICATES = {
+    TYPE: 'rdf:type',
+    NAME: 'lg:name',
+    DESCRIPTION: 'lg:description',
+    BLOOM_LEVEL: 'lg:bloomLevel',
+    DIFFICULTY: 'lg:difficulty',
+    IS_THRESHOLD: 'lg:isThresholdConcept',
+    MASTERY_THRESHOLD: 'lg:masteryThreshold',
+    ESTIMATED_MINUTES: 'lg:estimatedMinutes',
+    TAGS: 'lg:tags',
+    STANDARD_ALIGNMENT: 'lg:standardAlignment',
+    DOMAIN: 'lg:domain',
+    GRADE_LEVEL: 'lg:gradeLevel',
+    METADATA: 'lg:metadata',
+    CREATED_AT: 'lg:createdAt',
+    UPDATED_AT: 'lg:updatedAt',
+};
+/**
+ * Edge property predicates for triple mapping
+ */
+const EDGE_PREDICATES = {
+    TYPE: 'rdf:type',
+    PREREQUISITE_OF: 'lg:prerequisiteOf',
+    EDGE_STRENGTH: 'lg:strength',
+    EDGE_TYPE: 'lg:edgeType',
+    REASONING: 'lg:reasoning',
+    METADATA: 'lg:edgeMetadata',
+    CREATED_AT: 'lg:edgeCreatedAt',
+    SOURCE: 'lg:source',
+    TARGET: 'lg:target',
+};
+/**
+ * LevelGraph storage adapter.
+ *
+ * Stores skill graphs using RDF-style triples, compatible with
+ * LevelDB (Node.js) and IndexedDB (browser).
+ *
+ * @example
+ * ```typescript
+ * import { LevelGraphStorage } from 'learngraph/storage';
+ * import levelgraph from 'levelgraph';
+ * import level from 'level';
+ *
+ * // Node.js usage
+ * const storage = new LevelGraphStorage();
+ * await storage.connect({
+ *   backend: 'levelgraph',
+ *   path: './my-graph-db',
+ * });
+ *
+ * // Browser usage (with level-js)
+ * await storage.connect({
+ *   backend: 'levelgraph',
+ *   dbName: 'my-graph-db',
+ * });
+ * ```
+ */
+export class LevelGraphStorage {
+    db = null;
+    _connected = false;
+    config = null;
+    // ─────────────────────────────────────────────────────────────────────────────
+    // Triple Conversion Utilities
+    // ─────────────────────────────────────────────────────────────────────────────
+    /**
+     * Convert a SkillNode to triples
+     */
+    skillToTriples(skill) {
+        const id = skill.id;
+        const triples = [
+            { subject: id, predicate: SKILL_PREDICATES.TYPE, object: 'Skill' },
+            { subject: id, predicate: SKILL_PREDICATES.NAME, object: skill.name },
+            { subject: id, predicate: SKILL_PREDICATES.DESCRIPTION, object: skill.description },
+            { subject: id, predicate: SKILL_PREDICATES.BLOOM_LEVEL, object: skill.bloomLevel },
+            { subject: id, predicate: SKILL_PREDICATES.DIFFICULTY, object: String(skill.difficulty) },
+            { subject: id, predicate: SKILL_PREDICATES.IS_THRESHOLD, object: String(skill.isThresholdConcept) },
+            { subject: id, predicate: SKILL_PREDICATES.MASTERY_THRESHOLD, object: String(skill.masteryThreshold) },
+            { subject: id, predicate: SKILL_PREDICATES.ESTIMATED_MINUTES, object: String(skill.estimatedMinutes) },
+            { subject: id, predicate: SKILL_PREDICATES.TAGS, object: JSON.stringify(skill.tags) },
+            { subject: id, predicate: SKILL_PREDICATES.METADATA, object: JSON.stringify(skill.metadata) },
+            { subject: id, predicate: SKILL_PREDICATES.CREATED_AT, object: skill.createdAt },
+            { subject: id, predicate: SKILL_PREDICATES.UPDATED_AT, object: skill.updatedAt },
+        ];
+        if (skill.standardAlignment) {
+            triples.push({
+                subject: id,
+                predicate: SKILL_PREDICATES.STANDARD_ALIGNMENT,
+                object: JSON.stringify(skill.standardAlignment),
+            });
+        }
+        if (skill.domain) {
+            triples.push({
+                subject: id,
+                predicate: SKILL_PREDICATES.DOMAIN,
+                object: skill.domain,
+            });
+        }
+        if (skill.gradeLevel) {
+            triples.push({
+                subject: id,
+                predicate: SKILL_PREDICATES.GRADE_LEVEL,
+                object: skill.gradeLevel,
+            });
+        }
+        return triples;
+    }
+    /**
+     * Convert triples back to a SkillNode
+     */
+    triplesToSkill(triples) {
+        if (triples.length === 0)
+            return null;
+        const props = {};
+        const id = triples[0]?.subject;
+        if (!id)
+            return null;
+        for (const triple of triples) {
+            props[triple.predicate] = triple.object;
+        }
+        const tagsStr = props[SKILL_PREDICATES.TAGS];
+        const metadataStr = props[SKILL_PREDICATES.METADATA];
+        const node = {
+            id: createSkillId(id),
+            name: props[SKILL_PREDICATES.NAME] ?? '',
+            description: props[SKILL_PREDICATES.DESCRIPTION] ?? '',
+            bloomLevel: (props[SKILL_PREDICATES.BLOOM_LEVEL] ?? 'remember'),
+            difficulty: parseFloat(props[SKILL_PREDICATES.DIFFICULTY] ?? '0.5'),
+            isThresholdConcept: props[SKILL_PREDICATES.IS_THRESHOLD] === 'true',
+            masteryThreshold: parseFloat(props[SKILL_PREDICATES.MASTERY_THRESHOLD] ?? '0.8'),
+            estimatedMinutes: parseInt(props[SKILL_PREDICATES.ESTIMATED_MINUTES] ?? '30', 10),
+            tags: tagsStr ? JSON.parse(tagsStr) : [],
+            metadata: metadataStr ? JSON.parse(metadataStr) : {},
+            createdAt: props[SKILL_PREDICATES.CREATED_AT] ?? nowISO(),
+            updatedAt: props[SKILL_PREDICATES.UPDATED_AT] ?? nowISO(),
+        };
+        // Only add optional fields if they have values
+        const standardAlignmentStr = props[SKILL_PREDICATES.STANDARD_ALIGNMENT];
+        const domainStr = props[SKILL_PREDICATES.DOMAIN];
+        const gradeLevelStr = props[SKILL_PREDICATES.GRADE_LEVEL];
+        if (standardAlignmentStr) {
+            node.standardAlignment = JSON.parse(standardAlignmentStr);
+        }
+        if (domainStr) {
+            node.domain = domainStr;
+        }
+        if (gradeLevelStr) {
+            node.gradeLevel = gradeLevelStr;
+        }
+        return node;
+    }
+    /**
+     * Convert a PrerequisiteEdge to triples
+     */
+    edgeToTriples(edge) {
+        const id = edge.id;
+        const triples = [
+            { subject: id, predicate: EDGE_PREDICATES.TYPE, object: 'Edge' },
+            { subject: id, predicate: EDGE_PREDICATES.SOURCE, object: edge.sourceId },
+            { subject: id, predicate: EDGE_PREDICATES.TARGET, object: edge.targetId },
+            { subject: id, predicate: EDGE_PREDICATES.EDGE_STRENGTH, object: String(edge.strength) },
+            { subject: id, predicate: EDGE_PREDICATES.EDGE_TYPE, object: edge.type },
+            { subject: id, predicate: EDGE_PREDICATES.METADATA, object: JSON.stringify(edge.metadata) },
+            { subject: id, predicate: EDGE_PREDICATES.CREATED_AT, object: edge.createdAt },
+            // Store the relationship triple
+            {
+                subject: edge.sourceId,
+                predicate: EDGE_PREDICATES.PREREQUISITE_OF,
+                object: edge.targetId,
+            },
+        ];
+        if (edge.reasoning) {
+            triples.push({
+                subject: id,
+                predicate: EDGE_PREDICATES.REASONING,
+                object: edge.reasoning,
+            });
+        }
+        return triples;
+    }
+    /**
+     * Convert triples back to a PrerequisiteEdge
+     */
+    triplesToEdge(triples) {
+        if (triples.length === 0)
+            return null;
+        const props = {};
+        const id = triples[0]?.subject;
+        if (!id)
+            return null;
+        for (const triple of triples) {
+            props[triple.predicate] = triple.object;
+        }
+        const metadataStr = props[EDGE_PREDICATES.METADATA];
+        const reasoningStr = props[EDGE_PREDICATES.REASONING];
+        const edge = {
+            id: createEdgeId(id),
+            sourceId: createSkillId(props[EDGE_PREDICATES.SOURCE] ?? ''),
+            targetId: createSkillId(props[EDGE_PREDICATES.TARGET] ?? ''),
+            strength: parseFloat(props[EDGE_PREDICATES.EDGE_STRENGTH] ?? '0.5'),
+            type: (props[EDGE_PREDICATES.EDGE_TYPE] ?? 'soft'),
+            metadata: metadataStr ? JSON.parse(metadataStr) : {},
+            createdAt: props[EDGE_PREDICATES.CREATED_AT] ?? nowISO(),
+        };
+        // Only add optional fields if they have values
+        if (reasoningStr) {
+            edge.reasoning = reasoningStr;
+        }
+        return edge;
+    }
+    // ─────────────────────────────────────────────────────────────────────────────
+    // Promisified LevelGraph Operations
+    // ─────────────────────────────────────────────────────────────────────────────
+    put(triples) {
+        return new Promise((resolve, reject) => {
+            if (!this.db)
+                return reject(new Error('Not connected'));
+            this.db.put(triples, (err) => {
+                if (err)
+                    reject(err);
+                else
+                    resolve();
+            });
+        });
+    }
+    del(triples) {
+        return new Promise((resolve, reject) => {
+            if (!this.db)
+                return reject(new Error('Not connected'));
+            this.db.del(triples, (err) => {
+                if (err)
+                    reject(err);
+                else
+                    resolve();
+            });
+        });
+    }
+    get(pattern) {
+        return new Promise((resolve, reject) => {
+            if (!this.db)
+                return reject(new Error('Not connected'));
+            this.db.get(pattern, (err, triples) => {
+                if (err)
+                    reject(err);
+                else
+                    resolve(triples);
+            });
+        });
+    }
+    // ─────────────────────────────────────────────────────────────────────────────
+    // Connection Management
+    // ─────────────────────────────────────────────────────────────────────────────
+    async connect(config) {
+        if (config.backend !== 'levelgraph') {
+            throw new Error('LevelGraphStorage only supports "levelgraph" backend');
+        }
+        this.config = config;
+        try {
+            // Dynamic import of levelgraph and level
+            const levelgraph = await import('levelgraph');
+            const level = await import('level');
+            const dbPath = this.config.path || this.config.dbName || './learngraph-db';
+            const leveldb = new level.Level(dbPath);
+            // Cast the result to our LevelGraphDB interface
+            this.db = levelgraph.default(leveldb);
+            this._connected = true;
+        }
+        catch (error) {
+            throw new ConnectionError(`Failed to connect to LevelGraph: ${error instanceof Error ? error.message : String(error)}`, error instanceof Error ? error : undefined);
+        }
+    }
+    async disconnect() {
+        this.db = null;
+        this._connected = false;
+    }
+    isConnected() {
+        return this._connected;
+    }
+    async getStatus() {
+        const startTime = Date.now();
+        if (!this._connected || !this.db) {
+            return {
+                connected: false,
+                backend: 'levelgraph',
+                lastChecked: new Date(),
+                error: 'Not connected',
+            };
+        }
+        try {
+            // Simple health check - try to get any triple
+            await this.get({ predicate: SKILL_PREDICATES.TYPE });
+            return {
+                connected: true,
+                backend: 'levelgraph',
+                latencyMs: Date.now() - startTime,
+                lastChecked: new Date(),
+            };
+        }
+        catch (error) {
+            return {
+                connected: false,
+                backend: 'levelgraph',
+                lastChecked: new Date(),
+                error: error instanceof Error ? error.message : String(error),
+            };
+        }
+    }
+    // ─────────────────────────────────────────────────────────────────────────────
+    // Skill Node CRUD
+    // ─────────────────────────────────────────────────────────────────────────────
+    async createSkill(input) {
+        requireConnection(this._connected);
+        validateSkillInput(input);
+        const skill = inputToSkillNode(input);
+        // Check for duplicate
+        const existing = await this.get({
+            subject: skill.id,
+            predicate: SKILL_PREDICATES.TYPE,
+            object: 'Skill',
+        });
+        if (existing.length > 0) {
+            throw new DuplicateError('skill', skill.id);
+        }
+        const triples = this.skillToTriples(skill);
+        await this.put(triples);
+        return skill;
+    }
+    async getSkill(id) {
+        requireConnection(this._connected);
+        const triples = await this.get({ subject: id });
+        if (triples.length === 0)
+            return null;
+        // Check if it's actually a Skill
+        const typeTriple = triples.find((t) => t.predicate === SKILL_PREDICATES.TYPE && t.object === 'Skill');
+        if (!typeTriple)
+            return null;
+        return this.triplesToSkill(triples);
+    }
+    async getSkills(ids) {
+        requireConnection(this._connected);
+        const skills = [];
+        for (const id of ids) {
+            const skill = await this.getSkill(id);
+            if (skill)
+                skills.push(skill);
+        }
+        return skills;
+    }
+    async updateSkill(id, updates) {
+        requireConnection(this._connected);
+        const existing = await this.getSkill(id);
+        if (!existing) {
+            throw new NotFoundError('skill', id);
+        }
+        // Delete old triples
+        const oldTriples = await this.get({ subject: id });
+        await this.del(oldTriples.filter((t) => t.predicate.startsWith('lg:')));
+        // Create updated skill
+        const updated = {
+            ...existing,
+            ...updates,
+            id: existing.id,
+            createdAt: existing.createdAt,
+            updatedAt: nowISO(),
+        };
+        // Insert new triples
+        const newTriples = this.skillToTriples(updated);
+        await this.put(newTriples);
+        return updated;
+    }
+    async deleteSkill(id) {
+        requireConnection(this._connected);
+        // Delete skill triples
+        const skillTriples = await this.get({ subject: id });
+        if (skillTriples.length > 0) {
+            await this.del(skillTriples);
+        }
+        // Delete edges referencing this skill
+        const sourceEdges = await this.get({
+            predicate: EDGE_PREDICATES.SOURCE,
+            object: id,
+        });
+        const targetEdges = await this.get({
+            predicate: EDGE_PREDICATES.TARGET,
+            object: id,
+        });
+        for (const edge of [...sourceEdges, ...targetEdges]) {
+            const edgeTriples = await this.get({ subject: edge.subject });
+            await this.del(edgeTriples);
+        }
+        // Delete prerequisiteOf relationships
+        const prereqTriples = await this.get({
+            subject: id,
+            predicate: EDGE_PREDICATES.PREREQUISITE_OF,
+        });
+        if (prereqTriples.length > 0) {
+            await this.del(prereqTriples);
+        }
+        const depTriples = await this.get({
+            predicate: EDGE_PREDICATES.PREREQUISITE_OF,
+            object: id,
+        });
+        if (depTriples.length > 0) {
+            await this.del(depTriples);
+        }
+    }
+    async findSkills(query) {
+        requireConnection(this._connected);
+        // Get all skills
+        const typeTriples = await this.get({
+            predicate: SKILL_PREDICATES.TYPE,
+            object: 'Skill',
+        });
+        const skills = [];
+        for (const typeTriple of typeTriples) {
+            const skill = await this.getSkill(createSkillId(typeTriple.subject));
+            if (skill)
+                skills.push(skill);
+        }
+        // Apply filters in memory (LevelGraph doesn't support complex queries)
+        let results = skills;
+        if (query.filters) {
+            for (const filter of query.filters) {
+                results = results.filter((skill) => {
+                    const value = skill[filter.field];
+                    switch (filter.operator) {
+                        case 'eq':
+                            return value === filter.value;
+                        case 'neq':
+                            return value !== filter.value;
+                        case 'gt':
+                            return typeof value === 'number' && value > filter.value;
+                        case 'gte':
+                            return typeof value === 'number' && value >= filter.value;
+                        case 'lt':
+                            return typeof value === 'number' && value < filter.value;
+                        case 'lte':
+                            return typeof value === 'number' && value <= filter.value;
+                        case 'in':
+                            return Array.isArray(filter.value) && filter.value.includes(value);
+                        case 'contains':
+                            if (Array.isArray(value)) {
+                                return value.includes(filter.value);
+                            }
+                            if (typeof value === 'string') {
+                                return value.includes(filter.value);
+                            }
+                            return false;
+                        default:
+                            return true;
+                    }
+                });
+            }
+        }
+        // Apply sorting
+        if (query.sorting && query.sorting.length > 0) {
+            results.sort((a, b) => {
+                for (const sortItem of query.sorting) {
+                    const aVal = a[sortItem.field];
+                    const bVal = b[sortItem.field];
+                    const cmp = aVal < bVal ? -1 : aVal > bVal ? 1 : 0;
+                    if (cmp !== 0) {
+                        return sortItem.direction === 'asc' ? cmp : -cmp;
+                    }
+                }
+                return 0;
+            });
+        }
+        // Apply pagination
+        if (query.pagination) {
+            const { offset = 0, limit = 100 } = query.pagination;
+            results = results.slice(offset, offset + limit);
+        }
+        return results;
+    }
+    async countSkills(query) {
+        requireConnection(this._connected);
+        if (!query) {
+            const typeTriples = await this.get({
+                predicate: SKILL_PREDICATES.TYPE,
+                object: 'Skill',
+            });
+            return typeTriples.length;
+        }
+        const { pagination, ...queryWithoutPagination } = query;
+        const results = await this.findSkills(queryWithoutPagination);
+        return results.length;
+    }
+    // ─────────────────────────────────────────────────────────────────────────────
+    // Prerequisite Edge CRUD
+    // ─────────────────────────────────────────────────────────────────────────────
+    async createPrerequisite(input) {
+        requireConnection(this._connected);
+        validateEdgeInput(input);
+        // Verify source and target exist
+        const source = await this.getSkill(input.sourceId);
+        if (!source) {
+            throw new StorageReferenceError(input.id || 'new', input.sourceId, 'source');
+        }
+        const target = await this.getSkill(input.targetId);
+        if (!target) {
+            throw new StorageReferenceError(input.id || 'new', input.targetId, 'target');
+        }
+        const edge = inputToEdge(input);
+        // Check for duplicate
+        const existing = await this.get({
+            subject: edge.id,
+            predicate: EDGE_PREDICATES.TYPE,
+            object: 'Edge',
+        });
+        if (existing.length > 0) {
+            throw new DuplicateError('edge', edge.id);
+        }
+        const triples = this.edgeToTriples(edge);
+        await this.put(triples);
+        return edge;
+    }
+    async getPrerequisite(id) {
+        requireConnection(this._connected);
+        const triples = await this.get({ subject: id });
+        if (triples.length === 0)
+            return null;
+        const typeTriple = triples.find((t) => t.predicate === EDGE_PREDICATES.TYPE && t.object === 'Edge');
+        if (!typeTriple)
+            return null;
+        return this.triplesToEdge(triples);
+    }
+    async deletePrerequisite(id) {
+        requireConnection(this._connected);
+        const edge = await this.getPrerequisite(id);
+        if (!edge)
+            return;
+        // Delete edge triples
+        const edgeTriples = await this.get({ subject: id });
+        if (edgeTriples.length > 0) {
+            await this.del(edgeTriples);
+        }
+        // Delete the relationship triple
+        await this.del([
+            {
+                subject: edge.sourceId,
+                predicate: EDGE_PREDICATES.PREREQUISITE_OF,
+                object: edge.targetId,
+            },
+        ]);
+    }
+    async findPrerequisites(criteria) {
+        requireConnection(this._connected);
+        // Get all edges
+        const typeTriples = await this.get({
+            predicate: EDGE_PREDICATES.TYPE,
+            object: 'Edge',
+        });
+        const edges = [];
+        for (const typeTriple of typeTriples) {
+            const edge = await this.getPrerequisite(createEdgeId(typeTriple.subject));
+            if (edge)
+                edges.push(edge);
+        }
+        // Apply filters
+        let results = edges;
+        if (criteria.sourceId) {
+            results = results.filter((e) => e.sourceId === criteria.sourceId);
+        }
+        if (criteria.targetId) {
+            results = results.filter((e) => e.targetId === criteria.targetId);
+        }
+        if (criteria.type) {
+            results = results.filter((e) => e.type === criteria.type);
+        }
+        if (criteria.minStrength !== undefined) {
+            results = results.filter((e) => e.strength >= criteria.minStrength);
+        }
+        return results;
+    }
+    // ─────────────────────────────────────────────────────────────────────────────
+    // Graph Traversal
+    // ─────────────────────────────────────────────────────────────────────────────
+    async getPrerequisitesOf(skillId) {
+        requireConnection(this._connected);
+        const prereqTriples = await this.get({
+            predicate: EDGE_PREDICATES.PREREQUISITE_OF,
+            object: skillId,
+        });
+        const skills = [];
+        for (const triple of prereqTriples) {
+            const skill = await this.getSkill(createSkillId(triple.subject));
+            if (skill)
+                skills.push(skill);
+        }
+        return skills;
+    }
+    async getDependentsOf(skillId) {
+        requireConnection(this._connected);
+        const depTriples = await this.get({
+            subject: skillId,
+            predicate: EDGE_PREDICATES.PREREQUISITE_OF,
+        });
+        const skills = [];
+        for (const triple of depTriples) {
+            const skill = await this.getSkill(createSkillId(triple.object));
+            if (skill)
+                skills.push(skill);
+        }
+        return skills;
+    }
+    async getSubgraph(rootId, depth) {
+        requireConnection(this._connected);
+        const visitedNodes = new Set();
+        const subgraphNodes = [];
+        const subgraphEdges = [];
+        const queue = [
+            { id: rootId, level: 0 },
+        ];
+        while (queue.length > 0) {
+            const { id, level } = queue.shift();
+            if (visitedNodes.has(id) || level > depth) {
+                continue;
+            }
+            visitedNodes.add(id);
+            const node = await this.getSkill(id);
+            if (node) {
+                subgraphNodes.push(node);
+                // Get prerequisites
+                const prereqTriples = await this.get({
+                    predicate: EDGE_PREDICATES.PREREQUISITE_OF,
+                    object: id,
+                });
+                for (const triple of prereqTriples) {
+                    queue.push({ id: createSkillId(triple.subject), level: level + 1 });
+                }
+            }
+        }
+        // Get all edges between visited nodes
+        const allEdges = await this.findPrerequisites({});
+        for (const edge of allEdges) {
+            if (visitedNodes.has(edge.sourceId) &&
+                visitedNodes.has(edge.targetId)) {
+                subgraphEdges.push(edge);
+            }
+        }
+        return {
+            rootId,
+            depth,
+            nodes: subgraphNodes,
+            edges: subgraphEdges,
+        };
+    }
+    async getRootSkills() {
+        requireConnection(this._connected);
+        const allSkills = await this.findSkills({});
+        const hasPrereq = new Set();
+        const prereqTriples = await this.get({
+            predicate: EDGE_PREDICATES.PREREQUISITE_OF,
+        });
+        for (const triple of prereqTriples) {
+            hasPrereq.add(triple.object);
+        }
+        return allSkills.filter((skill) => !hasPrereq.has(skill.id));
+    }
+    async getLeafSkills() {
+        requireConnection(this._connected);
+        const allSkills = await this.findSkills({});
+        const hasDependents = new Set();
+        const prereqTriples = await this.get({
+            predicate: EDGE_PREDICATES.PREREQUISITE_OF,
+        });
+        for (const triple of prereqTriples) {
+            hasDependents.add(triple.subject);
+        }
+        return allSkills.filter((skill) => !hasDependents.has(skill.id));
+    }
+    async getPath(fromId, toId) {
+        requireConnection(this._connected);
+        const visited = new Set();
+        const parent = new Map();
+        const queue = [fromId];
+        visited.add(fromId);
+        while (queue.length > 0) {
+            const current = queue.shift();
+            if (current === toId) {
+                const path = [];
+                let node = toId;
+                while (node) {
+                    const skillNode = await this.getSkill(createSkillId(node));
+                    if (skillNode)
+                        path.unshift(skillNode);
+                    node = parent.get(node);
+                }
+                return path;
+            }
+            const dependents = await this.getDependentsOf(current);
+            for (const dep of dependents) {
+                const depId = dep.id;
+                if (!visited.has(depId)) {
+                    visited.add(depId);
+                    parent.set(depId, current);
+                    queue.push(dep.id);
+                }
+            }
+        }
+        return null;
+    }
+    // ─────────────────────────────────────────────────────────────────────────────
+    // Bulk Operations
+    // ─────────────────────────────────────────────────────────────────────────────
+    async importGraph(nodes, edges, options) {
+        requireConnection(this._connected);
+        const startTime = Date.now();
+        const result = {
+            nodesCreated: 0,
+            edgesCreated: 0,
+            nodesSkipped: 0,
+            edgesSkipped: 0,
+            errors: [],
+            durationMs: 0,
+        };
+        if (options?.clearExisting) {
+            await this.clearAll();
+        }
+        // Import nodes
+        for (const nodeInput of nodes) {
+            try {
+                const skill = inputToSkillNode(nodeInput);
+                const existing = await this.getSkill(skill.id);
+                if (existing) {
+                    result.nodesSkipped++;
+                }
+                else {
+                    const triples = this.skillToTriples(skill);
+                    await this.put(triples);
+                    result.nodesCreated++;
+                }
+            }
+            catch (error) {
+                result.errors.push({
+                    type: 'node',
+                    id: nodeInput.id || 'unknown',
+                    error: error instanceof Error ? error.message : String(error),
+                });
+            }
+        }
+        // Import edges
+        for (const edgeInput of edges) {
+            try {
+                const edge = inputToEdge(edgeInput);
+                const source = await this.getSkill(edge.sourceId);
+                if (!source) {
+                    throw new Error(`Source skill not found: ${edge.sourceId}`);
+                }
+                const target = await this.getSkill(edge.targetId);
+                if (!target) {
+                    throw new Error(`Target skill not found: ${edge.targetId}`);
+                }
+                const existing = await this.getPrerequisite(edge.id);
+                if (existing) {
+                    result.edgesSkipped++;
+                }
+                else {
+                    const triples = this.edgeToTriples(edge);
+                    await this.put(triples);
+                    result.edgesCreated++;
+                }
+            }
+            catch (error) {
+                result.errors.push({
+                    type: 'edge',
+                    id: edgeInput.id || 'unknown',
+                    error: error instanceof Error ? error.message : String(error),
+                });
+            }
+        }
+        result.durationMs = Date.now() - startTime;
+        return result;
+    }
+    async exportGraph() {
+        requireConnection(this._connected);
+        const nodes = await this.findSkills({});
+        const edges = await this.findPrerequisites({});
+        return {
+            version: GRAPH_VERSION,
+            exportedAt: nowISO(),
+            nodes,
+            edges,
+        };
+    }
+    async clearAll() {
+        requireConnection(this._connected);
+        // Get all triples and delete them
+        const allTriples = await this.get({});
+        if (allTriples.length > 0) {
+            await this.del(allTriples);
+        }
+    }
+    // ─────────────────────────────────────────────────────────────────────────────
+    // Analytics
+    // ─────────────────────────────────────────────────────────────────────────────
+    async getStats() {
+        requireConnection(this._connected);
+        const nodes = await this.findSkills({});
+        const edges = await this.findPrerequisites({});
+        return calculateStats(nodes, edges);
+    }
+}
+//# sourceMappingURL=levelgraph.js.map