learngraph 0.1.1 → 0.3.0

package/dist/types/llm/adapters/anthropic.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Anthropic adapter for LLM integration
+ *
+ * @packageDocumentation
+ */
+import type { LLMProvider, AnthropicConfig, CompletionRequest, CompletionResponse } from '../../types/llm.js';
+import { BaseLLMAdapter } from './base.js';
+/**
+ * Anthropic adapter for Claude models
+ */
+export declare class AnthropicAdapter extends BaseLLMAdapter {
+    private readonly baseUrl;
+    constructor(config: AnthropicConfig);
+    get provider(): LLMProvider;
+    complete(request: CompletionRequest): Promise<CompletionResponse>;
+}
+/**
+ * Create an Anthropic adapter from environment variables
+ */
+export declare function createAnthropicAdapter(model?: string, overrides?: Partial<AnthropicConfig>): AnthropicAdapter;
+//# sourceMappingURL=anthropic.d.ts.map

package/dist/types/llm/adapters/anthropic.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"anthropic.d.ts","sourceRoot":"","sources":["../../../../src/llm/adapters/anthropic.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,EACV,WAAW,EACX,eAAe,EACf,iBAAiB,EACjB,kBAAkB,EACnB,MAAM,oBAAoB,CAAC;AAC5B,OAAO,EAAE,cAAc,EAA4B,MAAM,WAAW,CAAC;AAiCrE;;GAEG;AACH,qBAAa,gBAAiB,SAAQ,cAAc;IAClD,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAS;gBAErB,MAAM,EAAE,eAAe;IAKnC,IAAI,QAAQ,IAAI,WAAW,CAE1B;IAEK,QAAQ,CAAC,OAAO,EAAE,iBAAiB,GAAG,OAAO,CAAC,kBAAkB,CAAC;CAyGxE;AAED;;GAEG;AACH,wBAAgB,sBAAsB,CACpC,KAAK,SAA+B,EACpC,SAAS,CAAC,EAAE,OAAO,CAAC,eAAe,CAAC,GACnC,gBAAgB,CAclB"}

package/dist/types/llm/adapters/base.d.ts

@@ -0,0 +1,46 @@
+/**
+ * Base adapter class for LLM providers
+ *
+ * @packageDocumentation
+ */
+import type { LLMProvider, LLMConfig, LLMAdapter, CompletionRequest, CompletionResponse } from '../../types/llm.js';
+/**
+ * LLM-related errors
+ */
+export declare class LLMError extends Error {
+    readonly code: LLMErrorCode;
+    readonly provider: LLMProvider;
+    readonly cause?: Error | undefined;
+    constructor(message: string, code: LLMErrorCode, provider: LLMProvider, cause?: Error | undefined);
+}
+export type LLMErrorCode = 'NOT_CONFIGURED' | 'API_ERROR' | 'RATE_LIMIT' | 'INVALID_RESPONSE' | 'TIMEOUT' | 'NETWORK_ERROR' | 'PARSE_ERROR';
+/**
+ * Default configuration values
+ */
+export declare const DEFAULT_CONFIG: {
+    maxTokens: number;
+    temperature: number;
+    timeout: number;
+    retries: number;
+};
+/**
+ * Abstract base class for LLM adapters
+ */
+export declare abstract class BaseLLMAdapter implements LLMAdapter {
+    protected config: LLMConfig;
+    constructor(config: LLMConfig);
+    abstract get provider(): LLMProvider;
+    get model(): string;
+    abstract complete(request: CompletionRequest): Promise<CompletionResponse>;
+    isConfigured(): boolean;
+    getConfig(): Omit<LLMConfig, 'apiKey'>;
+    /**
+     * Retry a function with exponential backoff
+     */
+    protected withRetry<T>(fn: () => Promise<T>, maxRetries?: number): Promise<T>;
+    /**
+     * Parse JSON from LLM response, handling common issues
+     */
+    protected parseJSON<T>(content: string): T;
+}
+//# sourceMappingURL=base.d.ts.map

package/dist/types/llm/adapters/base.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"base.d.ts","sourceRoot":"","sources":["../../../../src/llm/adapters/base.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,EACV,WAAW,EACX,SAAS,EACT,UAAU,EACV,iBAAiB,EACjB,kBAAkB,EACnB,MAAM,oBAAoB,CAAC;AAE5B;;GAEG;AACH,qBAAa,QAAS,SAAQ,KAAK;aAGf,IAAI,EAAE,YAAY;aAClB,QAAQ,EAAE,WAAW;aACrB,KAAK,CAAC,EAAE,KAAK;gBAH7B,OAAO,EAAE,MAAM,EACC,IAAI,EAAE,YAAY,EAClB,QAAQ,EAAE,WAAW,EACrB,KAAK,CAAC,EAAE,KAAK,YAAA;CAKhC;AAED,MAAM,MAAM,YAAY,GACpB,gBAAgB,GAChB,WAAW,GACX,YAAY,GACZ,kBAAkB,GAClB,SAAS,GACT,eAAe,GACf,aAAa,CAAC;AAElB;;GAEG;AACH,eAAO,MAAM,cAAc;;;;;CAK1B,CAAC;AAEF;;GAEG;AACH,8BAAsB,cAAe,YAAW,UAAU;IACxD,SAAS,CAAC,MAAM,EAAE,SAAS,CAAC;gBAEhB,MAAM,EAAE,SAAS;IAO7B,QAAQ,KAAK,QAAQ,IAAI,WAAW,CAAC;IAErC,IAAI,KAAK,IAAI,MAAM,CAElB;IAED,QAAQ,CAAC,QAAQ,CAAC,OAAO,EAAE,iBAAiB,GAAG,OAAO,CAAC,kBAAkB,CAAC;IAE1E,YAAY,IAAI,OAAO;IAOvB,SAAS,IAAI,IAAI,CAAC,SAAS,EAAE,QAAQ,CAAC;IAKtC;;OAEG;cACa,SAAS,CAAC,CAAC,EACzB,EAAE,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,EACpB,UAAU,SAAgD,GACzD,OAAO,CAAC,CAAC,CAAC;IA2Bb;;OAEG;IACH,SAAS,CAAC,SAAS,CAAC,CAAC,EAAE,OAAO,EAAE,MAAM,GAAG,CAAC;CAgB3C"}

package/dist/types/llm/adapters/index.d.ts

@@ -0,0 +1,11 @@
+/**
+ * LLM adapter exports
+ *
+ * @packageDocumentation
+ */
+export { BaseLLMAdapter, LLMError, DEFAULT_CONFIG } from './base.js';
+export type { LLMErrorCode } from './base.js';
+export { OpenAIAdapter, createOpenAIAdapter } from './openai.js';
+export { AnthropicAdapter, createAnthropicAdapter } from './anthropic.js';
+export { OllamaAdapter, createOllamaAdapter } from './ollama.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/types/llm/adapters/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/llm/adapters/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAE,cAAc,EAAE,QAAQ,EAAE,cAAc,EAAE,MAAM,WAAW,CAAC;AACrE,YAAY,EAAE,YAAY,EAAE,MAAM,WAAW,CAAC;AAE9C,OAAO,EAAE,aAAa,EAAE,mBAAmB,EAAE,MAAM,aAAa,CAAC;AACjE,OAAO,EAAE,gBAAgB,EAAE,sBAAsB,EAAE,MAAM,gBAAgB,CAAC;AAC1E,OAAO,EAAE,aAAa,EAAE,mBAAmB,EAAE,MAAM,aAAa,CAAC"}

package/dist/types/llm/adapters/ollama.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Ollama adapter for local LLM integration
+ *
+ * @packageDocumentation
+ */
+import type { LLMProvider, OllamaConfig, CompletionRequest, CompletionResponse } from '../../types/llm.js';
+import { BaseLLMAdapter } from './base.js';
+/**
+ * Ollama adapter for local models
+ */
+export declare class OllamaAdapter extends BaseLLMAdapter {
+    private readonly baseUrl;
+    constructor(config: OllamaConfig);
+    get provider(): LLMProvider;
+    isConfigured(): boolean;
+    complete(request: CompletionRequest): Promise<CompletionResponse>;
+    /**
+     * Check if Ollama is available
+     */
+    isAvailable(): Promise<boolean>;
+    /**
+     * List available models
+     */
+    listModels(): Promise<string[]>;
+}
+/**
+ * Create an Ollama adapter
+ */
+export declare function createOllamaAdapter(model?: string, overrides?: Partial<OllamaConfig>): OllamaAdapter;
+//# sourceMappingURL=ollama.d.ts.map

package/dist/types/llm/adapters/ollama.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ollama.d.ts","sourceRoot":"","sources":["../../../../src/llm/adapters/ollama.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,EACV,WAAW,EACX,YAAY,EACZ,iBAAiB,EACjB,kBAAkB,EACnB,MAAM,oBAAoB,CAAC;AAC5B,OAAO,EAAE,cAAc,EAA4B,MAAM,WAAW,CAAC;AAuBrE;;GAEG;AACH,qBAAa,aAAc,SAAQ,cAAc;IAC/C,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAS;gBAErB,MAAM,EAAE,YAAY;IAKhC,IAAI,QAAQ,IAAI,WAAW,CAE1B;IAED,YAAY,IAAI,OAAO;IAIjB,QAAQ,CAAC,OAAO,EAAE,iBAAiB,GAAG,OAAO,CAAC,kBAAkB,CAAC;IA+GvE;;OAEG;IACG,WAAW,IAAI,OAAO,CAAC,OAAO,CAAC;IAWrC;;OAEG;IACG,UAAU,IAAI,OAAO,CAAC,MAAM,EAAE,CAAC;CAgBtC;AAED;;GAEG;AACH,wBAAgB,mBAAmB,CACjC,KAAK,SAAa,EAClB,SAAS,CAAC,EAAE,OAAO,CAAC,YAAY,CAAC,GAChC,aAAa,CAOf"}

package/dist/types/llm/adapters/openai.d.ts

@@ -0,0 +1,22 @@
+/**
+ * OpenAI adapter for LLM integration
+ *
+ * @packageDocumentation
+ */
+import type { LLMProvider, OpenAIConfig, CompletionRequest, CompletionResponse } from '../../types/llm.js';
+import { BaseLLMAdapter } from './base.js';
+/**
+ * OpenAI adapter for chat completions
+ */
+export declare class OpenAIAdapter extends BaseLLMAdapter {
+    private readonly baseUrl;
+    private readonly organization?;
+    constructor(config: OpenAIConfig);
+    get provider(): LLMProvider;
+    complete(request: CompletionRequest): Promise<CompletionResponse>;
+}
+/**
+ * Create an OpenAI adapter from environment variables
+ */
+export declare function createOpenAIAdapter(model?: string, overrides?: Partial<OpenAIConfig>): OpenAIAdapter;
+//# sourceMappingURL=openai.d.ts.map

package/dist/types/llm/adapters/openai.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"openai.d.ts","sourceRoot":"","sources":["../../../../src/llm/adapters/openai.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,EACV,WAAW,EACX,YAAY,EACZ,iBAAiB,EACjB,kBAAkB,EACnB,MAAM,oBAAoB,CAAC;AAC5B,OAAO,EAAE,cAAc,EAA4B,MAAM,WAAW,CAAC;AAuCrE;;GAEG;AACH,qBAAa,aAAc,SAAQ,cAAc;IAC/C,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAS;IACjC,OAAO,CAAC,QAAQ,CAAC,YAAY,CAAC,CAAS;gBAE3B,MAAM,EAAE,YAAY;IAQhC,IAAI,QAAQ,IAAI,WAAW,CAE1B;IAEK,QAAQ,CAAC,OAAO,EAAE,iBAAiB,GAAG,OAAO,CAAC,kBAAkB,CAAC;CAuGxE;AAED;;GAEG;AACH,wBAAgB,mBAAmB,CACjC,KAAK,SAAW,EAChB,SAAS,CAAC,EAAE,OAAO,CAAC,YAAY,CAAC,GAChC,aAAa,CAcf"}

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

@@ -3,4 +3,9 @@
  *
  * @packageDocumentation
  */
+export type { LLMProvider, LLMConfig, OpenAIConfig, AnthropicConfig, OllamaConfig, MessageRole, ChatMessage, CompletionRequest, CompletionResponse, SkillExtractionRequest, ExtractedSkillLLM, SkillExtractionResponse, PrerequisiteInferenceRequest, InferredPrerequisite, PrerequisiteInferenceResponse, BloomAnalysisRequest, BloomAnalysisResponse, DecompositionRequest, DecompositionResponse, LLMAdapter, LLMOrchestrator as ILLMOrchestrator, } from '../types/llm.js';
+export { BaseLLMAdapter, LLMError, DEFAULT_CONFIG, OpenAIAdapter, createOpenAIAdapter, AnthropicAdapter, createAnthropicAdapter, OllamaAdapter, createOllamaAdapter, } from './adapters/index.js';
+export type { LLMErrorCode } from './adapters/index.js';
+export { LLMOrchestrator, createOrchestrator } from './orchestrator.js';
+export { SYSTEM_PROMPTS, EXTRACTION_SCHEMA, PREREQUISITE_SCHEMA, BLOOM_ANALYSIS_SCHEMA, DECOMPOSITION_SCHEMA, buildExtractionPrompt, buildPrerequisitePrompt, buildBloomPrompt, buildDecompositionPrompt, } from './prompts.js';
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/llm/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/llm/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAKH,YAAY,EACV,WAAW,EACX,SAAS,EACT,YAAY,EACZ,eAAe,EACf,YAAY,EACZ,WAAW,EACX,WAAW,EACX,iBAAiB,EACjB,kBAAkB,EAClB,sBAAsB,EACtB,iBAAiB,EACjB,uBAAuB,EACvB,4BAA4B,EAC5B,oBAAoB,EACpB,6BAA6B,EAC7B,oBAAoB,EACpB,qBAAqB,EACrB,oBAAoB,EACpB,qBAAqB,EACrB,UAAU,EACV,eAAe,IAAI,gBAAgB,GACpC,MAAM,iBAAiB,CAAC;AAKzB,OAAO,EACL,cAAc,EACd,QAAQ,EACR,cAAc,EACd,aAAa,EACb,mBAAmB,EACnB,gBAAgB,EAChB,sBAAsB,EACtB,aAAa,EACb,mBAAmB,GACpB,MAAM,qBAAqB,CAAC;AAC7B,YAAY,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAC;AAKxD,OAAO,EAAE,eAAe,EAAE,kBAAkB,EAAE,MAAM,mBAAmB,CAAC;AAKxE,OAAO,EACL,cAAc,EACd,iBAAiB,EACjB,mBAAmB,EACnB,qBAAqB,EACrB,oBAAoB,EACpB,qBAAqB,EACrB,uBAAuB,EACvB,gBAAgB,EAChB,wBAAwB,GACzB,MAAM,cAAc,CAAC"}

package/dist/types/llm/orchestrator.d.ts

@@ -0,0 +1,35 @@
+/**
+ * LLM orchestrator for educational tasks
+ *
+ * @packageDocumentation
+ */
+import type { LLMAdapter, LLMOrchestrator as ILLMOrchestrator, SkillExtractionRequest, SkillExtractionResponse, PrerequisiteInferenceRequest, PrerequisiteInferenceResponse, BloomAnalysisRequest, BloomAnalysisResponse, DecompositionRequest, DecompositionResponse } from '../types/llm.js';
+/**
+ * High-level orchestrator for LLM-based educational tasks
+ */
+export declare class LLMOrchestrator implements ILLMOrchestrator {
+    private readonly adapter;
+    constructor(adapter: LLMAdapter);
+    getAdapter(): LLMAdapter;
+    /**
+     * Extract skills from curriculum content
+     */
+    extractSkills(request: SkillExtractionRequest): Promise<SkillExtractionResponse>;
+    /**
+     * Infer prerequisites between skills
+     */
+    inferPrerequisites(request: PrerequisiteInferenceRequest): Promise<PrerequisiteInferenceResponse>;
+    /**
+     * Analyze Bloom's level of text
+     */
+    analyzeBloomLevel(request: BloomAnalysisRequest): Promise<BloomAnalysisResponse>;
+    /**
+     * Full curriculum decomposition into skill graph
+     */
+    decompose(request: DecompositionRequest): Promise<DecompositionResponse>;
+}
+/**
+ * Create an orchestrator with a specific adapter
+ */
+export declare function createOrchestrator(adapter: LLMAdapter): LLMOrchestrator;
+//# sourceMappingURL=orchestrator.d.ts.map

package/dist/types/llm/orchestrator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"orchestrator.d.ts","sourceRoot":"","sources":["../../../src/llm/orchestrator.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,EACV,UAAU,EACV,eAAe,IAAI,gBAAgB,EACnC,sBAAsB,EACtB,uBAAuB,EACvB,4BAA4B,EAC5B,6BAA6B,EAC7B,oBAAoB,EACpB,qBAAqB,EACrB,oBAAoB,EACpB,qBAAqB,EAItB,MAAM,iBAAiB,CAAC;AA+BzB;;GAEG;AACH,qBAAa,eAAgB,YAAW,gBAAgB;IAC1C,OAAO,CAAC,QAAQ,CAAC,OAAO;gBAAP,OAAO,EAAE,UAAU;IAEhD,UAAU,IAAI,UAAU;IAIxB;;OAEG;IACG,aAAa,CAAC,OAAO,EAAE,sBAAsB,GAAG,OAAO,CAAC,uBAAuB,CAAC;IAqDtF;;OAEG;IACG,kBAAkB,CACtB,OAAO,EAAE,4BAA4B,GACpC,OAAO,CAAC,6BAA6B,CAAC;IAuCzC;;OAEG;IACG,iBAAiB,CAAC,OAAO,EAAE,oBAAoB,GAAG,OAAO,CAAC,qBAAqB,CAAC;IA4BtF;;OAEG;IACG,SAAS,CAAC,OAAO,EAAE,oBAAoB,GAAG,OAAO,CAAC,qBAAqB,CAAC;CAkF/E;AAED;;GAEG;AACH,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,UAAU,GAAG,eAAe,CAEvE"}

package/dist/types/llm/prompts.d.ts

@@ -0,0 +1,269 @@
+/**
+ * Prompts for LLM-based educational tasks
+ *
+ * @packageDocumentation
+ */
+import type { BloomLevel } from '../types/bloom.js';
+export declare const SYSTEM_PROMPTS: {
+    skillExtraction: string;
+    prerequisiteInference: string;
+    bloomAnalysis: string;
+    curriculumDecomposition: string;
+};
+export declare const EXTRACTION_SCHEMA: {
+    type: string;
+    properties: {
+        skills: {
+            type: string;
+            items: {
+                type: string;
+                properties: {
+                    name: {
+                        type: string;
+                        description: string;
+                    };
+                    description: {
+                        type: string;
+                        description: string;
+                    };
+                    bloomLevel: {
+                        type: string;
+                        enum: string[];
+                        description: string;
+                    };
+                    difficulty: {
+                        type: string;
+                        minimum: number;
+                        maximum: number;
+                        description: string;
+                    };
+                    confidence: {
+                        type: string;
+                        minimum: number;
+                        maximum: number;
+                        description: string;
+                    };
+                    isThresholdConcept: {
+                        type: string;
+                        description: string;
+                    };
+                    estimatedMinutes: {
+                        type: string;
+                        description: string;
+                    };
+                    keywords: {
+                        type: string;
+                        items: {
+                            type: string;
+                        };
+                        description: string;
+                    };
+                    reasoning: {
+                        type: string;
+                        description: string;
+                    };
+                };
+                required: string[];
+            };
+        };
+        warnings: {
+            type: string;
+            items: {
+                type: string;
+            };
+            description: string;
+        };
+    };
+    required: string[];
+};
+export declare const PREREQUISITE_SCHEMA: {
+    type: string;
+    properties: {
+        prerequisites: {
+            type: string;
+            items: {
+                type: string;
+                properties: {
+                    sourceId: {
+                        type: string;
+                        description: string;
+                    };
+                    targetId: {
+                        type: string;
+                        description: string;
+                    };
+                    strength: {
+                        type: string;
+                        minimum: number;
+                        maximum: number;
+                        description: string;
+                    };
+                    type: {
+                        type: string;
+                        enum: string[];
+                        description: string;
+                    };
+                    confidence: {
+                        type: string;
+                        minimum: number;
+                        maximum: number;
+                        description: string;
+                    };
+                    reasoning: {
+                        type: string;
+                        description: string;
+                    };
+                };
+                required: string[];
+            };
+        };
+    };
+    required: string[];
+};
+export declare const BLOOM_ANALYSIS_SCHEMA: {
+    type: string;
+    properties: {
+        level: {
+            type: string;
+            enum: string[];
+            description: string;
+        };
+        confidence: {
+            type: string;
+            minimum: number;
+            maximum: number;
+            description: string;
+        };
+        indicators: {
+            type: string;
+            items: {
+                type: string;
+            };
+            description: string;
+        };
+        reasoning: {
+            type: string;
+            description: string;
+        };
+    };
+    required: string[];
+};
+export declare const DECOMPOSITION_SCHEMA: {
+    type: string;
+    properties: {
+        title: {
+            type: string;
+            description: string;
+        };
+        skills: {
+            type: string;
+            items: {
+                type: string;
+                properties: {
+                    id: {
+                        type: string;
+                        description: string;
+                    };
+                    name: {
+                        type: string;
+                    };
+                    description: {
+                        type: string;
+                    };
+                    bloomLevel: {
+                        type: string;
+                        enum: string[];
+                    };
+                    difficulty: {
+                        type: string;
+                        minimum: number;
+                        maximum: number;
+                    };
+                    isThresholdConcept: {
+                        type: string;
+                    };
+                    estimatedMinutes: {
+                        type: string;
+                    };
+                    keywords: {
+                        type: string;
+                        items: {
+                            type: string;
+                        };
+                    };
+                };
+                required: string[];
+            };
+        };
+        prerequisites: {
+            type: string;
+            items: {
+                type: string;
+                properties: {
+                    sourceId: {
+                        type: string;
+                    };
+                    targetId: {
+                        type: string;
+                    };
+                    strength: {
+                        type: string;
+                        minimum: number;
+                        maximum: number;
+                    };
+                    type: {
+                        type: string;
+                        enum: string[];
+                    };
+                    reasoning: {
+                        type: string;
+                    };
+                };
+                required: string[];
+            };
+        };
+        warnings: {
+            type: string;
+            items: {
+                type: string;
+            };
+        };
+    };
+    required: string[];
+};
+/**
+ * Build a skill extraction prompt
+ */
+export declare function buildExtractionPrompt(content: string, options?: {
+    domain?: string;
+    gradeLevel?: string;
+    context?: string;
+}): string;
+/**
+ * Build a prerequisite inference prompt
+ */
+export declare function buildPrerequisitePrompt(skills: Array<{
+    id: string;
+    name: string;
+    description: string;
+    bloomLevel: BloomLevel;
+    difficulty: number;
+}>, options?: {
+    domain?: string;
+    inferTransitive?: boolean;
+}): string;
+/**
+ * Build a Bloom's analysis prompt
+ */
+export declare function buildBloomPrompt(text: string, context?: string): string;
+/**
+ * Build a curriculum decomposition prompt
+ */
+export declare function buildDecompositionPrompt(content: string, options?: {
+    title?: string;
+    domain?: string;
+    gradeLevel?: string;
+    context?: string;
+    maxDepth?: number;
+}): string;
+//# sourceMappingURL=prompts.d.ts.map

package/dist/types/llm/prompts.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"prompts.d.ts","sourceRoot":"","sources":["../../../src/llm/prompts.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AAMpD,eAAO,MAAM,cAAc;;;;;CAkG1B,CAAC;AAMF,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAuD7B,CAAC;AAEF,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAqC/B,CAAC;AAEF,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;CAyBjC,CAAC;AAEF,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA4ChC,CAAC;AAMF;;GAEG;AACH,wBAAgB,qBAAqB,CACnC,OAAO,EAAE,MAAM,EACf,OAAO,CAAC,EAAE;IACR,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB,GACA,MAAM,CAiBR;AAED;;GAEG;AACH,wBAAgB,uBAAuB,CACrC,MAAM,EAAE,KAAK,CAAC;IACZ,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,EAAE,MAAM,CAAC;IACpB,UAAU,EAAE,UAAU,CAAC;IACvB,UAAU,EAAE,MAAM,CAAC;CACpB,CAAC,EACF,OAAO,CAAC,EAAE;IACR,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,eAAe,CAAC,EAAE,OAAO,CAAC;CAC3B,GACA,MAAM,CA2BR;AAED;;GAEG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,GAAG,MAAM,CAWvE;AAED;;GAEG;AACH,wBAAgB,wBAAwB,CACtC,OAAO,EAAE,MAAM,EACf,OAAO,CAAC,EAAE;IACR,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB,GACA,MAAM,CA2BR"}

package/dist/types/parsers/base.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Base parser utilities
+ *
+ * @packageDocumentation
+ */
+import type { ParseResult, ParseOptions, ParseStats, LearningObjective, ParseFormat } from '../types/parser.js';
+/**
+ * Default parse options
+ */
+export declare const DEFAULT_PARSE_OPTIONS: Required<ParseOptions>;
+/**
+ * Extract estimated time from text
+ */
+export declare function extractTime(text: string): number | undefined;
+/**
+ * Detect if a line is a learning objective
+ */
+export declare function isObjectiveLine(line: string, markers: string[]): boolean;
+/**
+ * Clean and normalize text
+ */
+export declare function cleanText(text: string): string;
+/**
+ * Generate a skill name from an objective
+ */
+export declare function objectiveToSkillName(objective: string): string;
+/**
+ * Create a learning objective from text
+ */
+export declare function createObjective(text: string, section?: string, week?: number): LearningObjective;
+/**
+ * Create empty parse result
+ */
+export declare function createEmptyResult(source: string, format: ParseFormat): ParseResult;
+/**
+ * Calculate parse statistics
+ */
+export declare function calculateStats(result: ParseResult, startTime: number): ParseStats;
+//# sourceMappingURL=base.d.ts.map

package/dist/types/parsers/base.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"base.d.ts","sourceRoot":"","sources":["../../../src/parsers/base.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,EACV,WAAW,EACX,YAAY,EACZ,UAAU,EACV,iBAAiB,EACjB,WAAW,EACZ,MAAM,oBAAoB,CAAC;AAG5B;;GAEG;AACH,eAAO,MAAM,qBAAqB,EAAE,QAAQ,CAAC,YAAY,CA6BxD,CAAC;AAYF;;GAEG;AACH,wBAAgB,WAAW,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAY5D;AAED;;GAEG;AACH,wBAAgB,eAAe,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,GAAG,OAAO,CAGxE;AAED;;GAEG;AACH,wBAAgB,SAAS,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAM9C;AAED;;GAEG;AACH,wBAAgB,oBAAoB,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,CA2B9D;AAED;;GAEG;AACH,wBAAgB,eAAe,CAC7B,IAAI,EAAE,MAAM,EACZ,OAAO,CAAC,EAAE,MAAM,EAChB,IAAI,CAAC,EAAE,MAAM,GACZ,iBAAiB,CAmBnB;AAED;;GAEG;AACH,wBAAgB,iBAAiB,CAC/B,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,WAAW,GAClB,WAAW,CAmBb;AAED;;GAEG;AACH,wBAAgB,cAAc,CAAC,MAAM,EAAE,WAAW,EAAE,SAAS,EAAE,MAAM,GAAG,UAAU,CA6BjF"}

package/dist/types/parsers/demo.d.ts

@@ -0,0 +1,87 @@
+/**
+ * Demo utilities for quick testing and exploration
+ *
+ * @packageDocumentation
+ */
+import type { ParseResult, SkillExtractionResult, ExtractionOptions } from '../types/parser.js';
+import type { SkillNode, PrerequisiteEdge, GraphStats } from '../types/index.js';
+import { type SampleSyllabusName } from './samples.js';
+/**
+ * Result of the demo function
+ */
+export interface DemoResult {
+    /** Parse result with extracted modules, topics, objectives */
+    parseResult: ParseResult;
+    /** Skill extraction result */
+    extraction: SkillExtractionResult;
+    /** Skills created in storage */
+    skills: SkillNode[];
+    /** Prerequisite edges created */
+    edges: PrerequisiteEdge[];
+    /** Graph statistics */
+    stats: GraphStats;
+}
+/**
+ * Try LearnGraph with a sample syllabus
+ *
+ * This is the easiest way to see LearnGraph in action.
+ *
+ * @example
+ * ```typescript
+ * import { tryWithSample } from 'learngraph/parsers';
+ *
+ * // Try with physics syllabus
+ * const result = await tryWithSample('physics');
+ * console.log(`Created ${result.skills.length} skills!`);
+ * console.log('Skills:', result.skills.map(s => s.name));
+ *
+ * // Try with kindergarten math
+ * const kResult = await tryWithSample('kindergarten');
+ * console.log(`Kindergarten: ${kResult.skills.length} skills`);
+ * ```
+ */
+export declare function tryWithSample(sample?: SampleSyllabusName): Promise<DemoResult>;
+/**
+ * Try LearnGraph with your own syllabus
+ *
+ * Paste your syllabus as markdown and see the magic happen!
+ *
+ * @example
+ * ```typescript
+ * import { tryWithSyllabus } from 'learngraph/parsers';
+ *
+ * const mySyllabus = `
+ * # My Course
+ *
+ * ## Week 1: Introduction
+ *
+ * ### Learning Objectives
+ * - Understand the course structure
+ * - Identify key topics
+ * - Apply basic concepts
+ * `;
+ *
+ * const result = await tryWithSyllabus(mySyllabus);
+ * console.log('Found', result.parseResult.stats.objectiveCount, 'objectives');
+ * console.log('Created', result.skills.length, 'skills');
+ *
+ * // See the skills
+ * for (const skill of result.skills) {
+ *   console.log(`- ${skill.name} (${skill.bloomLevel}, difficulty: ${skill.difficulty})`);
+ * }
+ * ```
+ */
+export declare function tryWithSyllabus(syllabus: string, options?: ExtractionOptions): Promise<DemoResult>;
+/**
+ * Quick console output of demo results
+ *
+ * @example
+ * ```typescript
+ * import { tryWithSample, printDemoResults } from 'learngraph/parsers';
+ *
+ * const result = await tryWithSample('physics');
+ * printDemoResults(result);
+ * ```
+ */
+export declare function printDemoResults(result: DemoResult): void;
+//# sourceMappingURL=demo.d.ts.map

package/dist/types/parsers/demo.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"demo.d.ts","sourceRoot":"","sources":["../../../src/parsers/demo.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,EAAE,WAAW,EAAE,qBAAqB,EAAE,iBAAiB,EAAE,MAAM,oBAAoB,CAAC;AAChG,OAAO,KAAK,EAAE,SAAS,EAAE,gBAAgB,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AAIjF,OAAO,EAAkB,KAAK,kBAAkB,EAAE,MAAM,cAAc,CAAC;AAEvE;;GAEG;AACH,MAAM,WAAW,UAAU;IACzB,8DAA8D;IAC9D,WAAW,EAAE,WAAW,CAAC;IACzB,8BAA8B;IAC9B,UAAU,EAAE,qBAAqB,CAAC;IAClC,gCAAgC;IAChC,MAAM,EAAE,SAAS,EAAE,CAAC;IACpB,iCAAiC;IACjC,KAAK,EAAE,gBAAgB,EAAE,CAAC;IAC1B,uBAAuB;IACvB,KAAK,EAAE,UAAU,CAAC;CACnB;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAsB,aAAa,CACjC,MAAM,GAAE,kBAA8B,GACrC,OAAO,CAAC,UAAU,CAAC,CAGrB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,wBAAsB,eAAe,CACnC,QAAQ,EAAE,MAAM,EAChB,OAAO,CAAC,EAAE,iBAAiB,GAC1B,OAAO,CAAC,UAAU,CAAC,CA2DrB;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,UAAU,GAAG,IAAI,CAsCzD"}

package/dist/types/parsers/extractor.d.ts

@@ -0,0 +1,43 @@
+/**
+ * Skill extractor - converts parsed syllabi into graph-ready skills
+ *
+ * @packageDocumentation
+ */
+import type { SkillExtractor, ParseResult, ExtractionOptions, SkillExtractionResult } from '../types/parser.js';
+/**
+ * Default extraction options
+ */
+export declare const DEFAULT_EXTRACTION_OPTIONS: Required<ExtractionOptions>;
+/**
+ * Basic skill extractor
+ *
+ * Converts parsed syllabus content into skills ready for graph storage.
+ *
+ * @example
+ * ```typescript
+ * import { MarkdownParser, BasicExtractor } from 'learngraph/parsers';
+ *
+ * const parser = new MarkdownParser();
+ * const extractor = new BasicExtractor();
+ *
+ * const parseResult = await parser.parse(syllabusMarkdown);
+ * const extraction = await extractor.extract(parseResult, {
+ *   tags: ['physics', 'intro'],
+ *   domain: 'Physics',
+ *   gradeLevel: 'Undergraduate'
+ * });
+ *
+ * // Now create skills in storage
+ * for (const { skill } of extraction.skills) {
+ *   await storage.createSkill(skill);
+ * }
+ * ```
+ */
+export declare class BasicExtractor implements SkillExtractor {
+    extract(parseResult: ParseResult, options?: ExtractionOptions): Promise<SkillExtractionResult>;
+    /**
+     * Suggest prerequisite relationships based on skill order and Bloom's levels
+     */
+    private suggestEdges;
+}
+//# sourceMappingURL=extractor.d.ts.map

package/dist/types/parsers/extractor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"extractor.d.ts","sourceRoot":"","sources":["../../../src/parsers/extractor.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,EACV,cAAc,EACd,WAAW,EACX,iBAAiB,EACjB,qBAAqB,EAKtB,MAAM,oBAAoB,CAAC;AAI5B;;GAEG;AACH,eAAO,MAAM,0BAA0B,EAAE,QAAQ,CAAC,iBAAiB,CAalE,CAAC;AAwBF;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,qBAAa,cAAe,YAAW,cAAc;IAC7C,OAAO,CACX,WAAW,EAAE,WAAW,EACxB,OAAO,CAAC,EAAE,iBAAiB,GAC1B,OAAO,CAAC,qBAAqB,CAAC;IAmGjC;;OAEG;IACH,OAAO,CAAC,YAAY;CAkCrB"}