learngraph 0.4.0 → 0.7.0

package/dist/types/mcp/tools.d.ts

@@ -0,0 +1,344 @@
+/**
+ * MCP Tool Definitions
+ *
+ * Tool implementations for LearnGraph MCP server.
+ * These tools enable Claude to interact with knowledge graphs.
+ *
+ * @packageDocumentation
+ */
+import { z } from 'zod';
+import type { GraphStorage } from '../types/index.js';
+import type { McpToolResult } from './types.js';
+export declare const ListSkillsSchema: z.ZodObject<{
+    limit: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    offset: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    bloomLevel: z.ZodOptional<z.ZodEnum<["remember", "understand", "apply", "analyze", "evaluate", "create"]>>;
+    tag: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    limit: number;
+    offset: number;
+    bloomLevel?: "remember" | "understand" | "apply" | "analyze" | "evaluate" | "create" | undefined;
+    tag?: string | undefined;
+}, {
+    bloomLevel?: "remember" | "understand" | "apply" | "analyze" | "evaluate" | "create" | undefined;
+    limit?: number | undefined;
+    tag?: string | undefined;
+    offset?: number | undefined;
+}>;
+export declare const GetSkillSchema: z.ZodObject<{
+    skillId: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    skillId: string;
+}, {
+    skillId: string;
+}>;
+export declare const CreateSkillSchema: z.ZodObject<{
+    name: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    bloomLevel: z.ZodEnum<["remember", "understand", "apply", "analyze", "evaluate", "create"]>;
+    estimatedMinutes: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    tags: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodString, "many">>>;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    bloomLevel: "remember" | "understand" | "apply" | "analyze" | "evaluate" | "create";
+    estimatedMinutes: number;
+    tags: string[];
+    description?: string | undefined;
+}, {
+    name: string;
+    bloomLevel: "remember" | "understand" | "apply" | "analyze" | "evaluate" | "create";
+    description?: string | undefined;
+    estimatedMinutes?: number | undefined;
+    tags?: string[] | undefined;
+}>;
+export declare const SearchSkillsSchema: z.ZodObject<{
+    query: z.ZodString;
+    limit: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+}, "strip", z.ZodTypeAny, {
+    query: string;
+    limit: number;
+}, {
+    query: string;
+    limit?: number | undefined;
+}>;
+export declare const GetPrerequisitesSchema: z.ZodObject<{
+    skillId: z.ZodString;
+    depth: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+}, "strip", z.ZodTypeAny, {
+    skillId: string;
+    depth: number;
+}, {
+    skillId: string;
+    depth?: number | undefined;
+}>;
+export declare const GetDependentsSchema: z.ZodObject<{
+    skillId: z.ZodString;
+    depth: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+}, "strip", z.ZodTypeAny, {
+    skillId: string;
+    depth: number;
+}, {
+    skillId: string;
+    depth?: number | undefined;
+}>;
+export declare const GetLearningPathSchema: z.ZodObject<{
+    targetSkillId: z.ZodString;
+    masteredSkillIds: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodString, "many">>>;
+}, "strip", z.ZodTypeAny, {
+    targetSkillId: string;
+    masteredSkillIds: string[];
+}, {
+    targetSkillId: string;
+    masteredSkillIds?: string[] | undefined;
+}>;
+export declare const GetZpdSkillsSchema: z.ZodObject<{
+    masteredSkillIds: z.ZodArray<z.ZodString, "many">;
+    limit: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+}, "strip", z.ZodTypeAny, {
+    limit: number;
+    masteredSkillIds: string[];
+}, {
+    masteredSkillIds: string[];
+    limit?: number | undefined;
+}>;
+export declare const CreatePrerequisiteSchema: z.ZodObject<{
+    sourceSkillId: z.ZodString;
+    targetSkillId: z.ZodString;
+    strength: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    type: z.ZodDefault<z.ZodOptional<z.ZodEnum<["hard", "soft", "recommended"]>>>;
+}, "strip", z.ZodTypeAny, {
+    strength: number;
+    type: "hard" | "soft" | "recommended";
+    targetSkillId: string;
+    sourceSkillId: string;
+}, {
+    targetSkillId: string;
+    sourceSkillId: string;
+    strength?: number | undefined;
+    type?: "hard" | "soft" | "recommended" | undefined;
+}>;
+export declare const GetGraphStatsSchema: z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>;
+export declare const ValidateCurriculumSchema: z.ZodObject<{
+    checkCycles: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    checkOrphans: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+}, "strip", z.ZodTypeAny, {
+    checkCycles: boolean;
+    checkOrphans: boolean;
+}, {
+    checkCycles?: boolean | undefined;
+    checkOrphans?: boolean | undefined;
+}>;
+/**
+ * List skills in the graph
+ */
+export declare function listSkills(storage: GraphStorage, params: z.infer<typeof ListSkillsSchema>): Promise<McpToolResult>;
+/**
+ * Get a single skill by ID
+ */
+export declare function getSkill(storage: GraphStorage, params: z.infer<typeof GetSkillSchema>): Promise<McpToolResult>;
+/**
+ * Create a new skill
+ */
+export declare function createSkill(storage: GraphStorage, params: z.infer<typeof CreateSkillSchema>): Promise<McpToolResult>;
+/**
+ * Search skills by name/description
+ */
+export declare function searchSkills(storage: GraphStorage, params: z.infer<typeof SearchSkillsSchema>): Promise<McpToolResult>;
+/**
+ * Get prerequisites for a skill
+ */
+export declare function getPrerequisites(storage: GraphStorage, params: z.infer<typeof GetPrerequisitesSchema>): Promise<McpToolResult>;
+/**
+ * Get dependents for a skill
+ */
+export declare function getDependents(storage: GraphStorage, params: z.infer<typeof GetDependentsSchema>): Promise<McpToolResult>;
+/**
+ * Get learning path to a target skill
+ */
+export declare function getLearningPath(storage: GraphStorage, params: z.infer<typeof GetLearningPathSchema>): Promise<McpToolResult>;
+/**
+ * Get skills in the Zone of Proximal Development
+ */
+export declare function getZpdSkills(storage: GraphStorage, params: z.infer<typeof GetZpdSkillsSchema>): Promise<McpToolResult>;
+/**
+ * Create a prerequisite relationship
+ */
+export declare function createPrerequisite(storage: GraphStorage, params: z.infer<typeof CreatePrerequisiteSchema>): Promise<McpToolResult>;
+/**
+ * Get graph statistics
+ */
+export declare function getGraphStats(storage: GraphStorage, _params: z.infer<typeof GetGraphStatsSchema>): Promise<McpToolResult>;
+/**
+ * Validate curriculum structure
+ */
+export declare function validateCurriculum(storage: GraphStorage, params: z.infer<typeof ValidateCurriculumSchema>): Promise<McpToolResult>;
+/**
+ * Export all tool definitions for MCP registration
+ */
+export declare const TOOL_DEFINITIONS: {
+    readonly list_skills: {
+        readonly description: "List all skills in the knowledge graph with optional filtering by Bloom's Taxonomy level or tags.";
+        readonly inputSchema: z.ZodObject<{
+            limit: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+            offset: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+            bloomLevel: z.ZodOptional<z.ZodEnum<["remember", "understand", "apply", "analyze", "evaluate", "create"]>>;
+            tag: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            limit: number;
+            offset: number;
+            bloomLevel?: "remember" | "understand" | "apply" | "analyze" | "evaluate" | "create" | undefined;
+            tag?: string | undefined;
+        }, {
+            bloomLevel?: "remember" | "understand" | "apply" | "analyze" | "evaluate" | "create" | undefined;
+            limit?: number | undefined;
+            tag?: string | undefined;
+            offset?: number | undefined;
+        }>;
+        readonly handler: typeof listSkills;
+    };
+    readonly get_skill: {
+        readonly description: "Get detailed information about a specific skill including its prerequisites and dependents.";
+        readonly inputSchema: z.ZodObject<{
+            skillId: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            skillId: string;
+        }, {
+            skillId: string;
+        }>;
+        readonly handler: typeof getSkill;
+    };
+    readonly create_skill: {
+        readonly description: "Create a new skill in the knowledge graph with name, Bloom's level, and optional metadata.";
+        readonly inputSchema: z.ZodObject<{
+            name: z.ZodString;
+            description: z.ZodOptional<z.ZodString>;
+            bloomLevel: z.ZodEnum<["remember", "understand", "apply", "analyze", "evaluate", "create"]>;
+            estimatedMinutes: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+            tags: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodString, "many">>>;
+        }, "strip", z.ZodTypeAny, {
+            name: string;
+            bloomLevel: "remember" | "understand" | "apply" | "analyze" | "evaluate" | "create";
+            estimatedMinutes: number;
+            tags: string[];
+            description?: string | undefined;
+        }, {
+            name: string;
+            bloomLevel: "remember" | "understand" | "apply" | "analyze" | "evaluate" | "create";
+            description?: string | undefined;
+            estimatedMinutes?: number | undefined;
+            tags?: string[] | undefined;
+        }>;
+        readonly handler: typeof createSkill;
+    };
+    readonly search_skills: {
+        readonly description: "Search for skills by name, description, or tags using fuzzy matching.";
+        readonly inputSchema: z.ZodObject<{
+            query: z.ZodString;
+            limit: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+        }, "strip", z.ZodTypeAny, {
+            query: string;
+            limit: number;
+        }, {
+            query: string;
+            limit?: number | undefined;
+        }>;
+        readonly handler: typeof searchSkills;
+    };
+    readonly get_prerequisites: {
+        readonly description: "Get all prerequisite skills for a given skill, optionally traversing multiple levels deep.";
+        readonly inputSchema: z.ZodObject<{
+            skillId: z.ZodString;
+            depth: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+        }, "strip", z.ZodTypeAny, {
+            skillId: string;
+            depth: number;
+        }, {
+            skillId: string;
+            depth?: number | undefined;
+        }>;
+        readonly handler: typeof getPrerequisites;
+    };
+    readonly get_dependents: {
+        readonly description: "Get all skills that depend on a given skill as a prerequisite.";
+        readonly inputSchema: z.ZodObject<{
+            skillId: z.ZodString;
+            depth: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+        }, "strip", z.ZodTypeAny, {
+            skillId: string;
+            depth: number;
+        }, {
+            skillId: string;
+            depth?: number | undefined;
+        }>;
+        readonly handler: typeof getDependents;
+    };
+    readonly get_learning_path: {
+        readonly description: "Generate an optimal learning path to a target skill, considering already mastered skills.";
+        readonly inputSchema: z.ZodObject<{
+            targetSkillId: z.ZodString;
+            masteredSkillIds: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodString, "many">>>;
+        }, "strip", z.ZodTypeAny, {
+            targetSkillId: string;
+            masteredSkillIds: string[];
+        }, {
+            targetSkillId: string;
+            masteredSkillIds?: string[] | undefined;
+        }>;
+        readonly handler: typeof getLearningPath;
+    };
+    readonly get_zpd_skills: {
+        readonly description: "Get skills in the learner's Zone of Proximal Development - skills they're ready to learn based on mastered prerequisites.";
+        readonly inputSchema: z.ZodObject<{
+            masteredSkillIds: z.ZodArray<z.ZodString, "many">;
+            limit: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+        }, "strip", z.ZodTypeAny, {
+            limit: number;
+            masteredSkillIds: string[];
+        }, {
+            masteredSkillIds: string[];
+            limit?: number | undefined;
+        }>;
+        readonly handler: typeof getZpdSkills;
+    };
+    readonly create_prerequisite: {
+        readonly description: "Create a prerequisite relationship between two skills (source skill is required before target skill).";
+        readonly inputSchema: z.ZodObject<{
+            sourceSkillId: z.ZodString;
+            targetSkillId: z.ZodString;
+            strength: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+            type: z.ZodDefault<z.ZodOptional<z.ZodEnum<["hard", "soft", "recommended"]>>>;
+        }, "strip", z.ZodTypeAny, {
+            strength: number;
+            type: "hard" | "soft" | "recommended";
+            targetSkillId: string;
+            sourceSkillId: string;
+        }, {
+            targetSkillId: string;
+            sourceSkillId: string;
+            strength?: number | undefined;
+            type?: "hard" | "soft" | "recommended" | undefined;
+        }>;
+        readonly handler: typeof createPrerequisite;
+    };
+    readonly get_graph_stats: {
+        readonly description: "Get statistics about the knowledge graph including skill counts, edge counts, and Bloom's Taxonomy distribution.";
+        readonly inputSchema: z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>;
+        readonly handler: typeof getGraphStats;
+    };
+    readonly validate_curriculum: {
+        readonly description: "Validate the curriculum structure checking for cycles and orphaned skills.";
+        readonly inputSchema: z.ZodObject<{
+            checkCycles: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+            checkOrphans: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+        }, "strip", z.ZodTypeAny, {
+            checkCycles: boolean;
+            checkOrphans: boolean;
+        }, {
+            checkCycles?: boolean | undefined;
+            checkOrphans?: boolean | undefined;
+        }>;
+        readonly handler: typeof validateCurriculum;
+    };
+};
+export type ToolName = keyof typeof TOOL_DEFINITIONS;
+//# sourceMappingURL=tools.d.ts.map

package/dist/types/mcp/tools.d.ts.map

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

package/dist/types/mcp/types.d.ts

@@ -0,0 +1,137 @@
+/**
+ * MCP Server Type Definitions
+ *
+ * Types for the LearnGraph MCP server integration.
+ *
+ * @packageDocumentation
+ */
+import type { GraphStorage } from '../types/index.js';
+/**
+ * MCP server configuration
+ */
+export interface McpServerConfig {
+    /** Storage backend for graph operations */
+    storage: GraphStorage;
+    /** Server name (default: learngraph) */
+    name?: string;
+    /** Server version (default: from package.json) */
+    version?: string;
+    /** Enable debug logging */
+    debug?: boolean;
+}
+/**
+ * MCP tool result content
+ */
+export interface McpTextContent {
+    type: 'text';
+    text: string;
+}
+export interface McpImageContent {
+    type: 'image';
+    data: string;
+    mimeType: string;
+}
+export type McpContent = McpTextContent | McpImageContent;
+/**
+ * MCP tool result
+ */
+export interface McpToolResult {
+    content: McpContent[];
+    isError?: boolean;
+}
+/**
+ * MCP resource metadata
+ */
+export interface McpResourceMeta {
+    uri: string;
+    name: string;
+    description?: string;
+    mimeType?: string;
+}
+/**
+ * MCP prompt argument
+ */
+export interface McpPromptArgument {
+    name: string;
+    description?: string;
+    required?: boolean;
+}
+/**
+ * MCP prompt definition
+ */
+export interface McpPromptMeta {
+    name: string;
+    description?: string;
+    arguments?: McpPromptArgument[];
+}
+/**
+ * Learner profile for MCP operations
+ */
+export interface LearnerProfile {
+    id: string;
+    masteredSkills: string[];
+    currentGoals?: string[];
+    preferences?: {
+        learningStyle?: 'visual' | 'auditory' | 'reading' | 'kinesthetic';
+        sessionDuration?: number;
+        difficultyPreference?: 'easy' | 'medium' | 'hard' | 'adaptive';
+    };
+}
+/**
+ * Learning path result
+ */
+export interface LearningPathResult {
+    path: Array<{
+        skillId: string;
+        skillName: string;
+        bloomLevel: string;
+        estimatedMinutes: number;
+        isPrerequisite: boolean;
+    }>;
+    totalEstimatedMinutes: number;
+    totalSkills: number;
+}
+/**
+ * ZPD (Zone of Proximal Development) result
+ */
+export interface ZpdResult {
+    readyToLearn: Array<{
+        skillId: string;
+        skillName: string;
+        bloomLevel: string;
+        readinessScore: number;
+        missingPrerequisites: string[];
+    }>;
+    almostReady: Array<{
+        skillId: string;
+        skillName: string;
+        prerequisitesNeeded: number;
+    }>;
+}
+/**
+ * Skill search result
+ */
+export interface SkillSearchResult {
+    skills: Array<{
+        id: string;
+        name: string;
+        description?: string;
+        bloomLevel: string;
+        tags: string[];
+        matchScore: number;
+    }>;
+    totalCount: number;
+}
+/**
+ * Graph statistics
+ */
+export interface GraphStatistics {
+    totalSkills: number;
+    totalEdges: number;
+    averagePrerequisites: number;
+    maxDepth: number;
+    rootSkills: number;
+    leafSkills: number;
+    bloomDistribution: Record<string, number>;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/types/mcp/types.d.ts.map

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

package/dist/types/query/index.d.ts

@@ -1,7 +1,15 @@
 /**
  * Query and traversal engines
  *
+ * This module provides intelligent query engines for:
+ * - Zone of Proximal Development (ZPD) calculation
+ * - Learning path generation
+ * - Spaced repetition scheduling
+ *
  * @packageDocumentation
  */
 export type { QueryOperator, QueryFilter, QuerySort, QueryPagination, SkillQuery, ZPDResult, LearningPath, LearningSession, ReviewSchedule, ReviewItem, ZPDOptions, PathOptions, ReviewOptions, } from '../types/query.js';
+export { ZPDCalculator, createZPDCalculator, ZPD_DEFAULTS, type LearnerProfile, } from './zpd.js';
+export { PathGenerator, createPathGenerator, PATH_DEFAULTS, type LearnerState, } from './path.js';
+export { SpacedRepetitionScheduler, createSpacedRepetitionScheduler, calculateSM2, REVIEW_DEFAULTS, SM2_CONSTANTS, type ReviewQuality, type ReviewState, type SM2Result, } from './spaced-repetition.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/types/query/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/query/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAGH,YAAY,EACV,aAAa,EACb,WAAW,EACX,SAAS,EACT,eAAe,EACf,UAAU,EACV,SAAS,EACT,YAAY,EACZ,eAAe,EACf,cAAc,EACd,UAAU,EACV,UAAU,EACV,WAAW,EACX,aAAa,GACd,MAAM,mBAAmB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/query/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAGH,YAAY,EACV,aAAa,EACb,WAAW,EACX,SAAS,EACT,eAAe,EACf,UAAU,EACV,SAAS,EACT,YAAY,EACZ,eAAe,EACf,cAAc,EACd,UAAU,EACV,UAAU,EACV,WAAW,EACX,aAAa,GACd,MAAM,mBAAmB,CAAC;AAG3B,OAAO,EACL,aAAa,EACb,mBAAmB,EACnB,YAAY,EACZ,KAAK,cAAc,GACpB,MAAM,UAAU,CAAC;AAGlB,OAAO,EACL,aAAa,EACb,mBAAmB,EACnB,aAAa,EACb,KAAK,YAAY,GAClB,MAAM,WAAW,CAAC;AAGnB,OAAO,EACL,yBAAyB,EACzB,+BAA+B,EAC/B,YAAY,EACZ,eAAe,EACf,aAAa,EACb,KAAK,aAAa,EAClB,KAAK,WAAW,EAChB,KAAK,SAAS,GACf,MAAM,wBAAwB,CAAC"}

package/dist/types/query/path.d.ts

@@ -0,0 +1,102 @@
+/**
+ * Learning Path Generator
+ *
+ * Generates personalized learning paths from current state to target skills.
+ * Uses topological sorting and groups skills into manageable sessions.
+ *
+ * @packageDocumentation
+ */
+import type { SkillId } from '../types/skill.js';
+import type { MasteryState } from '../types/mastery.js';
+import type { GraphStorage } from '../types/storage.js';
+import type { LearningPath, PathOptions } from '../types/query.js';
+/**
+ * Default options for path generation
+ */
+export declare const PATH_DEFAULTS: Required<PathOptions>;
+/**
+ * Learner state for path generation
+ */
+export interface LearnerState {
+    /** Mastery states for skills (keyed by skill ID) */
+    masteryStates: Map<SkillId, MasteryState>;
+}
+/**
+ * Learning Path Generator
+ *
+ * Generates optimal learning paths to reach target skills by:
+ * 1. Finding all unmastered prerequisites
+ * 2. Topologically sorting based on dependencies
+ * 3. Grouping into sessions based on cognitive load
+ *
+ * @example
+ * ```typescript
+ * const generator = new PathGenerator(storage);
+ *
+ * const path = await generator.generatePath(
+ *   'advanced-skill',
+ *   learnerState,
+ *   { sessionMinutes: 45 }
+ * );
+ *
+ * console.log(`Path has ${path.skills.length} skills`);
+ * console.log(`Estimated time: ${path.totalMinutes} minutes`);
+ * ```
+ */
+export declare class PathGenerator {
+    private readonly storage;
+    constructor(storage: GraphStorage);
+    /**
+     * Generate a learning path to a target skill
+     *
+     * @param targetId - The skill to learn
+     * @param learner - Current learner state
+     * @param options - Path generation options
+     * @returns Learning path with skills grouped into sessions
+     */
+    generatePath(targetId: SkillId, learner: LearnerState, options?: PathOptions): Promise<LearningPath | null>;
+    /**
+     * Generate paths to multiple target skills
+     *
+     * @param targetIds - Skills to learn
+     * @param learner - Current learner state
+     * @param options - Path generation options
+     * @returns Array of learning paths
+     */
+    generatePaths(targetIds: SkillId[], learner: LearnerState, options?: PathOptions): Promise<LearningPath[]>;
+    /**
+     * Get a merged learning path for multiple targets
+     * Combines all required skills and eliminates duplicates
+     */
+    generateMergedPath(targetIds: SkillId[], learner: LearnerState, options?: PathOptions): Promise<LearningPath | null>;
+    /**
+     * Get all transitive prerequisites of a skill
+     */
+    private getTransitivePrerequisites;
+    /**
+     * Filter skills to only unmastered ones
+     */
+    private filterUnmastered;
+    /**
+     * Topologically sort skills based on prerequisites
+     * Skills with no unmastered prerequisites come first
+     */
+    private topologicalSort;
+    /**
+     * Group skills into learning sessions based on target duration
+     */
+    private groupIntoSessions;
+    /**
+     * Create a learning session from a group of skills
+     */
+    private createSession;
+    /**
+     * Determine the focus/theme of a session
+     */
+    private determineFocus;
+}
+/**
+ * Create a path generator
+ */
+export declare function createPathGenerator(storage: GraphStorage): PathGenerator;
+//# sourceMappingURL=path.d.ts.map

package/dist/types/query/path.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"path.d.ts","sourceRoot":"","sources":["../../../src/query/path.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,KAAK,EAAa,OAAO,EAAE,MAAM,mBAAmB,CAAC;AAC5D,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAC;AACxD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAC;AACxD,OAAO,KAAK,EAAE,YAAY,EAAmB,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAEpF;;GAEG;AACH,eAAO,MAAM,aAAa,EAAE,QAAQ,CAAC,WAAW,CAI/C,CAAC;AAEF;;GAEG;AACH,MAAM,WAAW,YAAY;IAC3B,oDAAoD;IACpD,aAAa,EAAE,GAAG,CAAC,OAAO,EAAE,YAAY,CAAC,CAAC;CAC3C;AAED;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,qBAAa,aAAa;IACZ,OAAO,CAAC,QAAQ,CAAC,OAAO;gBAAP,OAAO,EAAE,YAAY;IAElD;;;;;;;OAOG;IACG,YAAY,CAChB,QAAQ,EAAE,OAAO,EACjB,OAAO,EAAE,YAAY,EACrB,OAAO,GAAE,WAAgB,GACxB,OAAO,CAAC,YAAY,GAAG,IAAI,CAAC;IA4D/B;;;;;;;OAOG;IACG,aAAa,CACjB,SAAS,EAAE,OAAO,EAAE,EACpB,OAAO,EAAE,YAAY,EACrB,OAAO,GAAE,WAAgB,GACxB,OAAO,CAAC,YAAY,EAAE,CAAC;IAa1B;;;OAGG;IACG,kBAAkB,CACtB,SAAS,EAAE,OAAO,EAAE,EACpB,OAAO,EAAE,YAAY,EACrB,OAAO,GAAE,WAAgB,GACxB,OAAO,CAAC,YAAY,GAAG,IAAI,CAAC;IAiE/B;;OAEG;YACW,0BAA0B;IAyBxC;;OAEG;YACW,gBAAgB;IAmB9B;;;OAGG;YACW,eAAe;IA0C7B;;OAEG;IACH,OAAO,CAAC,iBAAiB;IA+BzB;;OAEG;IACH,OAAO,CAAC,aAAa;IA0BrB;;OAEG;IACH,OAAO,CAAC,cAAc;CAqBvB;AAED;;GAEG;AACH,wBAAgB,mBAAmB,CAAC,OAAO,EAAE,YAAY,GAAG,aAAa,CAExE"}