learnhouse-mcp-server 1.0.0

package/src/test-api.ts

@@ -0,0 +1,185 @@
+/**
+ * LearnHouse API Client Tests
+ * 
+ * Run with: npm test
+ */
+
+import { LearnHouseClient } from "./client.js";
+
+const BASE_URL = process.env.LEARNHOUSE_URL || "http://localhost:3000";
+const ORG_ID = parseInt(process.env.LEARNHOUSE_ORG_ID || "1");
+const EMAIL = process.env.LEARNHOUSE_EMAIL || "admin@ai-automate.me";
+const PASSWORD = process.env.LEARNHOUSE_PASSWORD || "";
+
+async function runTests() {
+  console.log("🧪 LearnHouse API Client Tests\n");
+  console.log(`   Base URL: ${BASE_URL}`);
+  console.log(`   Org ID: ${ORG_ID}`);
+  console.log(`   Email: ${EMAIL}\n`);
+
+  const client = new LearnHouseClient({
+    baseUrl: BASE_URL,
+    orgId: ORG_ID,
+  });
+
+  let passed = 0;
+  let failed = 0;
+
+  async function test(name: string, fn: () => Promise<void>) {
+    try {
+      await fn();
+      console.log(`  ✅ ${name}`);
+      passed++;
+    } catch (error) {
+      console.log(`  ❌ ${name}`);
+      console.log(`     Error: ${error instanceof Error ? error.message : error}`);
+      failed++;
+    }
+  }
+
+  // ===== Authentication Tests =====
+  console.log("\n📋 Authentication Tests");
+  
+  await test("Health check (no auth)", async () => {
+    const result = await client.healthCheck();
+    if (!result.status) throw new Error("No status in response");
+  });
+
+  if (!PASSWORD) {
+    console.log("\n⚠️  Set LEARNHOUSE_PASSWORD to run authenticated tests\n");
+    return;
+  }
+
+  await test("Login with credentials", async () => {
+    const result = await client.login(EMAIL, PASSWORD);
+    if (!result.tokens.access_token) throw new Error("No access token");
+    if (!result.user.email) throw new Error("No user email");
+  });
+
+  await test("Get current user", async () => {
+    const user = await client.getCurrentUser();
+    if (!user.email) throw new Error("No email in user");
+    console.log(`     User: ${user.username} (${user.email})`);
+  });
+
+  // ===== Organization Tests =====
+  console.log("\n📋 Organization Tests");
+
+  await test("List organizations", async () => {
+    const orgs = await client.listOrganizations();
+    if (!Array.isArray(orgs)) throw new Error("Expected array");
+    console.log(`     Found ${orgs.length} organization(s)`);
+  });
+
+  await test("Get organization by ID", async () => {
+    const org = await client.getOrganization(ORG_ID);
+    if (!org.name) throw new Error("No org name");
+    console.log(`     Org: ${org.name} (${org.slug})`);
+  });
+
+  // ===== Course Tests =====
+  console.log("\n📋 Course Tests");
+
+  let testCourse: Awaited<ReturnType<typeof client.getCourse>> | null = null;
+
+  await test("List courses", async () => {
+    const courses = await client.listCourses(1, 10);
+    if (!Array.isArray(courses)) throw new Error("Expected array");
+    console.log(`     Found ${courses.length} course(s)`);
+    if (courses.length > 0) {
+      testCourse = courses[0];
+    }
+  });
+
+  if (testCourse) {
+    await test("Get course by UUID", async () => {
+      const course = await client.getCourse(testCourse!.course_uuid);
+      if (course.id !== testCourse!.id) throw new Error("Course ID mismatch");
+    });
+
+    await test("Get course metadata", async () => {
+      const meta = await client.getCourseMeta(testCourse!.course_uuid);
+      if (!meta.chapters) throw new Error("No chapters in metadata");
+      console.log(`     Course "${meta.name}" has ${meta.chapters.length} chapters`);
+    });
+  }
+
+  // ===== Chapter Tests =====
+  console.log("\n📋 Chapter Tests");
+
+  let testChapter: Awaited<ReturnType<typeof client.getChapter>> | null = null;
+
+  if (testCourse) {
+    await test("List chapters for course", async () => {
+      const chapters = await client.listChapters(testCourse!.id, 1, 10);
+      if (!Array.isArray(chapters)) throw new Error("Expected array");
+      console.log(`     Found ${chapters.length} chapter(s)`);
+      if (chapters.length > 0) {
+        testChapter = chapters[0];
+      }
+    });
+
+    if (testChapter) {
+      await test("Get chapter by ID", async () => {
+        const chapter = await client.getChapter(testChapter!.id);
+        if (chapter.id !== testChapter!.id) throw new Error("Chapter ID mismatch");
+        console.log(`     Chapter: ${chapter.name}`);
+      });
+    }
+  }
+
+  // ===== Activity Tests =====
+  console.log("\n📋 Activity Tests");
+
+  let testActivity: Awaited<ReturnType<typeof client.getActivity>> | null = null;
+
+  if (testChapter) {
+    await test("List activities for chapter", async () => {
+      const activities = await client.listActivities(testChapter!.id);
+      if (!Array.isArray(activities)) throw new Error("Expected array");
+      console.log(`     Found ${activities.length} activity(ies)`);
+      if (activities.length > 0) {
+        testActivity = activities[0];
+      }
+    });
+
+    if (testActivity) {
+      await test("Get activity by UUID", async () => {
+        const activity = await client.getActivity(testActivity!.activity_uuid);
+        if (activity.id !== testActivity!.id) throw new Error("Activity ID mismatch");
+        console.log(`     Activity: ${activity.name}`);
+      });
+    }
+  }
+
+  // ===== Collection Tests =====
+  console.log("\n📋 Collection Tests");
+
+  await test("List collections", async () => {
+    const collections = await client.listCollections(1, 10);
+    if (!Array.isArray(collections)) throw new Error("Expected array");
+    console.log(`     Found ${collections.length} collection(s)`);
+  });
+
+  // ===== Search Tests =====
+  console.log("\n📋 Search Tests");
+
+  await test("Search for courses", async () => {
+    const results = await client.search("MCP", "courses");
+    console.log(`     Found ${results.courses?.length || 0} course(s) matching "MCP"`);
+  });
+
+  // ===== Summary =====
+  console.log("\n" + "=".repeat(50));
+  console.log(`📊 Results: ${passed} passed, ${failed} failed`);
+  console.log("=".repeat(50) + "\n");
+
+  if (failed > 0) {
+    process.exit(1);
+  }
+}
+
+runTests().catch((error) => {
+  console.error("Fatal error:", error);
+  process.exit(1);
+});

package/src/types.ts

@@ -0,0 +1,243 @@
+/**
+ * LearnHouse API Client Configuration
+ */
+export interface LearnHouseConfig {
+  baseUrl: string;
+  orgId: number;
+  accessToken?: string;
+}
+
+/**
+ * Activity types supported by LearnHouse
+ */
+export enum ActivityType {
+  TYPE_DYNAMIC = "TYPE_DYNAMIC",
+  TYPE_VIDEO = "TYPE_VIDEO",
+  TYPE_DOCUMENT = "TYPE_DOCUMENT",
+  TYPE_ASSIGNMENT = "TYPE_ASSIGNMENT",
+  TYPE_CUSTOM = "TYPE_CUSTOM",
+}
+
+export enum ActivitySubType {
+  SUBTYPE_DYNAMIC_PAGE = "SUBTYPE_DYNAMIC_PAGE",
+  SUBTYPE_VIDEO_YOUTUBE = "SUBTYPE_VIDEO_YOUTUBE",
+  SUBTYPE_VIDEO_HOSTED = "SUBTYPE_VIDEO_HOSTED",
+  SUBTYPE_DOCUMENT_PDF = "SUBTYPE_DOCUMENT_PDF",
+  SUBTYPE_DOCUMENT_DOC = "SUBTYPE_DOCUMENT_DOC",
+  SUBTYPE_ASSIGNMENT_ANY = "SUBTYPE_ASSIGNMENT_ANY",
+  SUBTYPE_CUSTOM = "SUBTYPE_CUSTOM",
+}
+
+/**
+ * TipTap content node types
+ */
+export interface TipTapNode {
+  type: string;
+  attrs?: Record<string, unknown>;
+  content?: TipTapNode[];
+  text?: string;
+}
+
+export interface TipTapDocument {
+  type: "doc";
+  content: TipTapNode[];
+}
+
+/**
+ * User types
+ */
+export interface User {
+  id: number;
+  user_uuid: string;
+  email: string;
+  username: string;
+  first_name?: string;
+  last_name?: string;
+  avatar_image?: string;
+  creation_date: string;
+  update_date: string;
+}
+
+export interface LoginResponse {
+  user: User;
+  tokens: {
+    access_token: string;
+    refresh_token: string;
+  };
+}
+
+/**
+ * Organization types
+ */
+export interface Organization {
+  id: number;
+  org_uuid: string;
+  name: string;
+  slug: string;
+  description?: string;
+  logo_url?: string;
+  creation_date: string;
+  update_date: string;
+}
+
+/**
+ * Course types
+ */
+export interface Course {
+  id: number;
+  course_uuid: string;
+  name: string;
+  description: string;
+  about?: string;
+  public: boolean;
+  org_id: number;
+  thumbnail_image?: string;
+  thumbnail_video?: string;
+  thumbnail_type: "IMAGE" | "VIDEO";
+  learnings?: string;
+  tags?: string;
+  creation_date: string;
+  update_date: string;
+}
+
+export interface CourseCreate {
+  name: string;
+  description: string;
+  public?: boolean;
+  about?: string;
+  learnings?: string[];
+  tags?: string[];
+}
+
+export interface CourseUpdate {
+  name?: string;
+  description?: string;
+  public?: boolean;
+  about?: string;
+  learnings?: string;
+  tags?: string;
+  thumbnail_image?: string;
+  thumbnail_type?: "IMAGE" | "VIDEO";
+}
+
+export interface FullCourse extends Course {
+  chapters: Chapter[];
+}
+
+/**
+ * Chapter types
+ */
+export interface Chapter {
+  id: number;
+  chapter_uuid: string;
+  name: string;
+  description?: string;
+  org_id: number;
+  course_id: number;
+  activities: Activity[];
+  creation_date: string;
+  update_date: string;
+}
+
+export interface ChapterCreate {
+  name: string;
+  description?: string;
+  org_id: number;
+  course_id: number;
+}
+
+export interface ChapterUpdate {
+  name?: string;
+  description?: string;
+}
+
+/**
+ * Activity types
+ */
+export interface Activity {
+  id: number;
+  activity_uuid: string;
+  name: string;
+  activity_type: ActivityType;
+  activity_sub_type: ActivitySubType;
+  content: TipTapDocument | Record<string, unknown>;
+  details?: Record<string, unknown>;
+  published: boolean;
+  org_id: number;
+  course_id: number;
+  creation_date: string;
+  update_date: string;
+}
+
+export interface ActivityCreate {
+  name: string;
+  chapter_id: number;
+  activity_type?: ActivityType;
+  activity_sub_type?: ActivitySubType;
+  content?: TipTapDocument | Record<string, unknown>;
+  published?: boolean;
+  details?: Record<string, unknown>;
+}
+
+export interface ActivityUpdate {
+  name?: string;
+  content?: TipTapDocument | Record<string, unknown>;
+  activity_type?: ActivityType;
+  activity_sub_type?: ActivitySubType;
+  published?: boolean;
+  details?: Record<string, unknown>;
+}
+
+/**
+ * Collection types
+ */
+export interface Collection {
+  id: number;
+  collection_uuid: string;
+  name: string;
+  description?: string;
+  org_id: number;
+  courses: Course[];
+  creation_date: string;
+  update_date: string;
+}
+
+export interface CollectionCreate {
+  name: string;
+  description?: string;
+  org_id: number;
+  courses?: number[];
+  public?: boolean;
+}
+
+/**
+ * Trail/Progress types
+ */
+export interface TrailProgress {
+  course_uuid: string;
+  completion_percentage: number;
+  completed_activities: number;
+  total_activities: number;
+}
+
+export interface ActivityStatus {
+  activity_uuid: string;
+  completed: boolean;
+}
+
+/**
+ * Search types
+ */
+export interface SearchResult {
+  courses?: Course[];
+  users?: User[];
+  collections?: Collection[];
+}
+
+/**
+ * API Error
+ */
+export interface ApiError {
+  detail: string;
+  status?: number;
+}

package/tsconfig.json

@@ -0,0 +1,17 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "ESNext",
+    "moduleResolution": "bundler",
+    "esModuleInterop": true,
+    "strict": true,
+    "skipLibCheck": true,
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "declaration": true,
+    "resolveJsonModule": true,
+    "lib": ["ES2022"]
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist"]
+}