@vue-skuilder/mcp 0.1.8-3

package/dist/index.js

@@ -0,0 +1,1630 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  CourseConfigUriSchema: () => CourseConfigUriSchema,
+  CreateCardInputSchema: () => CreateCardInputSchema,
+  DeleteCardInputSchema: () => DeleteCardInputSchema,
+  MCPServer: () => MCPServer,
+  RESOURCE_PATTERNS: () => RESOURCE_PATTERNS,
+  TOOL_PATTERNS: () => TOOL_PATTERNS,
+  TagCardInputSchema: () => TagCardInputSchema,
+  UpdateCardInputSchema: () => UpdateCardInputSchema,
+  handleCardsAllResource: () => handleCardsAllResource,
+  handleCardsEloResource: () => handleCardsEloResource,
+  handleCardsShapeResource: () => handleCardsShapeResource,
+  handleCardsTagResource: () => handleCardsTagResource,
+  handleCourseConfigResource: () => handleCourseConfigResource,
+  handleCreateCard: () => handleCreateCard,
+  handleDeleteCard: () => handleDeleteCard,
+  handleShapeSpecificResource: () => handleShapeSpecificResource,
+  handleShapesAllResource: () => handleShapesAllResource,
+  handleTagCard: () => handleTagCard,
+  handleTagSpecificResource: () => handleTagSpecificResource,
+  handleTagsAllResource: () => handleTagsAllResource,
+  handleTagsDistributionResource: () => handleTagsDistributionResource,
+  handleTagsExclusiveResource: () => handleTagsExclusiveResource,
+  handleTagsIntersectResource: () => handleTagsIntersectResource,
+  handleTagsStatsResource: () => handleTagsStatsResource,
+  handleTagsUnionResource: () => handleTagsUnionResource,
+  handleUpdateCard: () => handleUpdateCard
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/server.ts
+var import_mcp = require("@modelcontextprotocol/sdk/server/mcp.js");
+
+// src/resources/course.ts
+var import_zod = require("zod");
+async function handleCourseConfigResource(courseDB) {
+  try {
+    const config = await courseDB.getCourseConfig();
+    const eloStats = {
+      min: 1e3,
+      max: 2e3,
+      mean: 1500,
+      distribution: [100, 200, 300, 250, 150]
+      // Placeholder histogram
+    };
+    return {
+      config,
+      eloStats
+    };
+  } catch (error) {
+    throw new Error(`Failed to load course config: ${error instanceof Error ? error.message : "Unknown error"}`);
+  }
+}
+var CourseConfigUriSchema = import_zod.z.string().regex(/^course:\/\/config$/);
+
+// src/resources/cards.ts
+var import_zod3 = require("zod");
+
+// src/utils/pouchdb.ts
+function isSuccessRow(row) {
+  return row.doc != null && !("error" in row);
+}
+
+// src/utils/tools.ts
+var import_zod2 = require("zod");
+var MCP_AGENT_AUTHOR = "mcp-agent";
+function handleToolError(error, context) {
+  if (error instanceof import_zod2.z.ZodError) {
+    throw new Error(`Invalid input: ${error.errors.map((e) => e.message).join(", ")}`);
+  }
+  const message = error instanceof Error ? error.message : "Unknown error";
+  console.error(`Error in ${context}:`, error);
+  throw new Error(`${context} failed: ${message}`);
+}
+function logToolStart(toolName, input) {
+  console.log(`[${toolName}] Starting with input:`, JSON.stringify(input, null, 2));
+}
+function logToolSuccess(toolName, result) {
+  console.log(`[${toolName}] Completed successfully:`, JSON.stringify(result, null, 2));
+}
+function logToolWarning(toolName, message, details) {
+  console.warn(`[${toolName}] Warning: ${message}`, details || "");
+}
+function logToolError(toolName, message, error) {
+  console.error(`[${toolName}] Error: ${message}`, error || "");
+}
+
+// src/resources/cards.ts
+var EloRangeSchema = import_zod3.z.object({
+  min: import_zod3.z.number().min(0).max(5e3),
+  max: import_zod3.z.number().min(0).max(5e3)
+}).refine((data) => data.min <= data.max, {
+  message: "Min ELO must be less than or equal to max ELO"
+});
+async function handleCardsAllResource(courseDB, limit = 50, offset = 0) {
+  try {
+    const courseInfo = await courseDB.getCourseInfo();
+    const cardIds = await courseDB.getCardsByELO(1500, limit + offset);
+    const targetCardIds = cardIds.slice(offset, offset + limit);
+    if (targetCardIds.length === 0) {
+      return {
+        cards: [],
+        total: courseInfo.cardCount,
+        page: Math.floor(offset / limit) + 1,
+        limit,
+        filter: "all"
+      };
+    }
+    const cardDocs = await courseDB.getCourseDocs(targetCardIds);
+    const eloData = await courseDB.getCardEloData(targetCardIds);
+    const eloMap = new Map(eloData.map((elo, index) => [targetCardIds[index], elo.global?.score || 1500]));
+    const cards = [];
+    for (const row of cardDocs.rows) {
+      if (isSuccessRow(row)) {
+        const doc = row.doc;
+        cards.push({
+          cardId: doc._id,
+          datashape: doc.shape?.name || "unknown",
+          data: doc.data || {},
+          tags: [],
+          // Will be populated separately if needed
+          elo: eloMap.get(doc._id),
+          created: doc.created,
+          modified: doc.modified
+        });
+      }
+    }
+    return {
+      cards,
+      total: courseInfo.cardCount,
+      page: Math.floor(offset / limit) + 1,
+      limit,
+      filter: "all"
+    };
+  } catch (error) {
+    console.error("Error fetching all cards:", error);
+    throw new Error(`Failed to fetch cards: ${error instanceof Error ? error.message : "Unknown error"}`);
+  }
+}
+async function handleCardsTagResource(courseDB, tagName, limit = 50, offset = 0) {
+  try {
+    const tag = await courseDB.getTag(tagName);
+    if (!tag) {
+      throw new Error(`Tag not found: ${tagName}`);
+    }
+    return {
+      cards: [],
+      total: 0,
+      page: Math.floor(offset / limit) + 1,
+      limit,
+      filter: `tag:${tagName}`
+    };
+  } catch (error) {
+    console.error(`Error fetching cards for tag ${tagName}:`, error);
+    throw new Error(`Failed to fetch cards for tag ${tagName}: ${error instanceof Error ? error.message : "Unknown error"}`);
+  }
+}
+async function handleCardsShapeResource(courseDB, shapeName, limit = 50, offset = 0) {
+  try {
+    const courseConfig = await courseDB.getCourseConfig();
+    const validShapes = courseConfig.dataShapes.map((ds) => ds.name);
+    if (!validShapes.includes(shapeName)) {
+      throw new Error(`DataShape not found: ${shapeName}. Available: ${validShapes.join(", ")}`);
+    }
+    const allCardIds = await courseDB.getCardsByELO(1500, 1e3);
+    if (allCardIds.length === 0) {
+      return {
+        cards: [],
+        total: 0,
+        page: Math.floor(offset / limit) + 1,
+        limit,
+        filter: `shape:${shapeName}`
+      };
+    }
+    const cardDocs = await courseDB.getCourseDocs(allCardIds);
+    const filteredCardIds = [];
+    const allFilteredRows = [];
+    for (const row of cardDocs.rows) {
+      if (isSuccessRow(row) && row.doc.shape?.name === shapeName) {
+        allFilteredRows.push(row);
+        filteredCardIds.push(row.doc._id);
+      }
+    }
+    const paginatedRows = allFilteredRows.slice(offset, offset + limit);
+    const paginatedCardIds = paginatedRows.map((row) => row.doc._id);
+    const eloData = await courseDB.getCardEloData(paginatedCardIds);
+    const eloMap = new Map(eloData.map((elo, index) => [paginatedCardIds[index], elo.global?.score || 1500]));
+    const cards = [];
+    for (const row of paginatedRows) {
+      if (isSuccessRow(row)) {
+        const doc = row.doc;
+        cards.push({
+          cardId: doc._id,
+          datashape: doc.shape?.name || "unknown",
+          data: doc.data || {},
+          tags: [],
+          elo: eloMap.get(doc._id),
+          created: doc.created,
+          modified: doc.modified
+        });
+      }
+    }
+    const totalFiltered = filteredCardIds.length;
+    return {
+      cards,
+      total: totalFiltered,
+      page: Math.floor(offset / limit) + 1,
+      limit,
+      filter: `shape:${shapeName}`
+    };
+  } catch (error) {
+    console.error(`Error fetching cards for shape ${shapeName}:`, error);
+    throw new Error(`Failed to fetch cards for shape ${shapeName}: ${error instanceof Error ? error.message : "Unknown error"}`);
+  }
+}
+async function handleCardsEloResource(courseDB, eloRange, limit = 50, offset = 0) {
+  try {
+    const [minStr, maxStr] = eloRange.split("-");
+    if (!minStr || !maxStr) {
+      throw new Error(`Invalid ELO range format: ${eloRange}. Expected format: min-max (e.g., 1200-1800)`);
+    }
+    const parsedRange = EloRangeSchema.parse({
+      min: parseInt(minStr, 10),
+      max: parseInt(maxStr, 10)
+    });
+    const targetElo = Math.floor((parsedRange.min + parsedRange.max) / 2);
+    const cardIds = await courseDB.getCardsByELO(targetElo, 1e3);
+    if (cardIds.length === 0) {
+      return {
+        cards: [],
+        total: 0,
+        page: Math.floor(offset / limit) + 1,
+        limit,
+        filter: `elo:${eloRange}`
+      };
+    }
+    const eloData = await courseDB.getCardEloData(cardIds);
+    const filteredEloData = eloData.map((elo, index) => ({ elo, cardId: cardIds[index] })).filter(({ elo }) => {
+      const score = elo.global?.score || 1500;
+      return score >= parsedRange.min && score <= parsedRange.max;
+    });
+    const paginatedEloData = filteredEloData.slice(offset, offset + limit);
+    const paginatedCardIds = paginatedEloData.map(({ cardId }) => cardId);
+    if (paginatedCardIds.length === 0) {
+      return {
+        cards: [],
+        total: filteredEloData.length,
+        page: Math.floor(offset / limit) + 1,
+        limit,
+        filter: `elo:${eloRange}`
+      };
+    }
+    const cardDocs = await courseDB.getCourseDocs(paginatedCardIds);
+    const eloMap = new Map(paginatedEloData.map(({ elo, cardId }) => [cardId, elo.global?.score || 1500]));
+    const cards = [];
+    for (const row of cardDocs.rows) {
+      if (isSuccessRow(row)) {
+        const doc = row.doc;
+        cards.push({
+          cardId: doc._id,
+          datashape: doc.shape?.name || "unknown",
+          data: doc.data || {},
+          tags: [],
+          elo: eloMap.get(doc._id),
+          created: doc.created,
+          modified: doc.modified
+        });
+      }
+    }
+    return {
+      cards,
+      total: filteredEloData.length,
+      page: Math.floor(offset / limit) + 1,
+      limit,
+      filter: `elo:${eloRange}`
+    };
+  } catch (error) {
+    console.error(`Error fetching cards for ELO range ${eloRange}:`, error);
+    throw new Error(`Failed to fetch cards for ELO range ${eloRange}: ${error instanceof Error ? error.message : "Unknown error"}`);
+  }
+}
+
+// src/resources/shapes.ts
+async function handleShapesAllResource(courseDB) {
+  try {
+    const courseConfig = await courseDB.getCourseConfig();
+    const dataShapes = courseConfig.dataShapes || [];
+    const shapes = dataShapes.map((shape) => ({
+      name: shape.name,
+      description: `DataShape for ${shape.name} content type`,
+      fields: shape.fields?.map((field) => ({
+        name: field.name,
+        type: field.type || "string",
+        required: field.required || false,
+        description: field.description || `Field for ${field.name}`
+      })) || [],
+      category: "course-content",
+      examples: []
+      // Could be populated with example cards
+    }));
+    const availableShapes = dataShapes.map((shape) => shape.name);
+    return {
+      shapes,
+      total: shapes.length,
+      availableShapes
+    };
+  } catch (error) {
+    console.error("Error fetching all shapes:", error);
+    throw new Error(`Failed to fetch shapes: ${error instanceof Error ? error.message : "Unknown error"}`);
+  }
+}
+async function handleShapeSpecificResource(courseDB, shapeName) {
+  try {
+    const courseConfig = await courseDB.getCourseConfig();
+    const dataShapes = courseConfig.dataShapes || [];
+    const targetShape = dataShapes.find((shape) => shape.name === shapeName);
+    if (!targetShape) {
+      const availableShapes = dataShapes.map((s) => s.name);
+      throw new Error(`DataShape not found: ${shapeName}. Available shapes: ${availableShapes.join(", ")}`);
+    }
+    let examples = [];
+    try {
+      const cardIds = await courseDB.getCardsByELO(1500, 10);
+      if (cardIds.length > 0) {
+        const cardDocs = await courseDB.getCourseDocs(cardIds.slice(0, 5));
+        examples = [];
+        for (const row of cardDocs.rows) {
+          if (isSuccessRow(row) && row.doc.shape?.name === shapeName) {
+            const data = row.doc?.data;
+            if (data) {
+              examples.push(data);
+              if (examples.length >= 3) break;
+            }
+          }
+        }
+      }
+    } catch (error) {
+      console.warn("Could not fetch examples for shape:", error);
+    }
+    return {
+      name: targetShape.name,
+      description: `DataShape definition for ${targetShape.name} content type`,
+      fields: targetShape.fields?.map((field) => ({
+        name: field.name,
+        type: field.type || "string",
+        required: field.required || false,
+        description: field.description || `Field for ${field.name}`
+      })) || [],
+      category: "course-content",
+      examples
+    };
+  } catch (error) {
+    console.error(`Error fetching shape ${shapeName}:`, error);
+    throw new Error(`Failed to fetch shape ${shapeName}: ${error instanceof Error ? error.message : "Unknown error"}`);
+  }
+}
+
+// src/resources/tags.ts
+async function handleTagsAllResource(courseDB) {
+  try {
+    const tagStubsResponse = await courseDB.getCourseTagStubs();
+    const tagStubs = tagStubsResponse.rows || [];
+    const tags = [];
+    for (const stub of tagStubs) {
+      if (stub.doc) {
+        tags.push({
+          name: stub.doc.name || stub.id,
+          description: stub.doc.snippet || `Tag: ${stub.doc.name}`,
+          cardCount: stub.doc.taggedCards?.length || 0,
+          created: stub.doc.created,
+          author: stub.doc.author,
+          metadata: stub.doc.metadata
+        });
+      }
+    }
+    return {
+      tags,
+      total: tags.length,
+      stats: {
+        totalTags: tags.length,
+        totalTaggedCards: 0,
+        // Would need additional queries
+        averageTagsPerCard: 0,
+        // Would need calculation
+        mostUsedTags: []
+        // Would need tag usage analysis
+      }
+    };
+  } catch (error) {
+    console.error("Error fetching all tags:", error);
+    throw new Error(`Failed to fetch tags: ${error instanceof Error ? error.message : "Unknown error"}`);
+  }
+}
+async function handleTagsStatsResource(courseDB) {
+  try {
+    const tagStubsResponse = await courseDB.getCourseTagStubs();
+    const totalTags = tagStubsResponse.rows?.length || 0;
+    const courseInfo = await courseDB.getCourseInfo();
+    console.log("Course info loaded for stats:", courseInfo.cardCount);
+    return {
+      totalTags,
+      totalTaggedCards: 0,
+      // Placeholder
+      averageTagsPerCard: 0,
+      // Placeholder
+      mostUsedTags: []
+      // Placeholder
+    };
+  } catch (error) {
+    console.error("Error fetching tag stats:", error);
+    throw new Error(`Failed to fetch tag statistics: ${error instanceof Error ? error.message : "Unknown error"}`);
+  }
+}
+async function handleTagSpecificResource(courseDB, tagName) {
+  try {
+    const tag = await courseDB.getTag(tagName);
+    if (!tag) {
+      throw new Error(`Tag not found: ${tagName}`);
+    }
+    return {
+      name: tag.name || tagName,
+      description: tag.snippet || `Tag: ${tagName}`,
+      cardCount: tag.taggedCards?.length || 0,
+      created: tag.created,
+      author: tag.author,
+      metadata: tag.metadata
+    };
+  } catch (error) {
+    console.error(`Error fetching tag ${tagName}:`, error);
+    throw new Error(`Failed to fetch tag ${tagName}: ${error instanceof Error ? error.message : "Unknown error"}`);
+  }
+}
+async function handleTagsUnionResource(courseDB, tagsParam) {
+  try {
+    const tags = tagsParam.split("+").map((tag) => tag.trim());
+    if (tags.length === 0) {
+      throw new Error("No tags specified for union operation");
+    }
+    for (const tagName of tags) {
+      try {
+        await courseDB.getTag(tagName);
+      } catch {
+        throw new Error(`Tag not found: ${tagName}`);
+      }
+    }
+    return {
+      cardIds: [],
+      // Placeholder
+      tags,
+      operation: "union"
+    };
+  } catch (error) {
+    console.error(`Error performing tags union for ${tagsParam}:`, error);
+    throw new Error(`Failed to perform tags union: ${error instanceof Error ? error.message : "Unknown error"}`);
+  }
+}
+async function handleTagsIntersectResource(courseDB, tagsParam) {
+  try {
+    const tags = tagsParam.split("+").map((tag) => tag.trim());
+    if (tags.length === 0) {
+      throw new Error("No tags specified for intersect operation");
+    }
+    for (const tagName of tags) {
+      try {
+        await courseDB.getTag(tagName);
+      } catch {
+        throw new Error(`Tag not found: ${tagName}`);
+      }
+    }
+    return {
+      cardIds: [],
+      // Placeholder
+      tags,
+      operation: "intersect"
+    };
+  } catch (error) {
+    console.error(`Error performing tags intersect for ${tagsParam}:`, error);
+    throw new Error(`Failed to perform tags intersect: ${error instanceof Error ? error.message : "Unknown error"}`);
+  }
+}
+async function handleTagsExclusiveResource(courseDB, tagsParam) {
+  try {
+    const [includeTag, excludeTag] = tagsParam.split("-").map((tag) => tag.trim());
+    if (!includeTag || !excludeTag) {
+      throw new Error("Both include and exclude tags must be specified (format: tag1-tag2)");
+    }
+    try {
+      await courseDB.getTag(includeTag);
+      await courseDB.getTag(excludeTag);
+    } catch (error) {
+      throw new Error(`One or both tags not found: ${includeTag}, ${excludeTag}`);
+    }
+    return {
+      cardIds: [],
+      // Placeholder
+      includeTag,
+      excludeTag,
+      operation: "exclusive"
+    };
+  } catch (error) {
+    console.error(`Error performing tags exclusive for ${tagsParam}:`, error);
+    throw new Error(`Failed to perform tags exclusive: ${error instanceof Error ? error.message : "Unknown error"}`);
+  }
+}
+async function handleTagsDistributionResource(courseDB) {
+  try {
+    const tagStubsResponse = await courseDB.getCourseTagStubs();
+    const tags = tagStubsResponse.rows || [];
+    const courseInfo = await courseDB.getCourseInfo();
+    const distribution = tags.map((stub) => ({
+      tagName: stub.doc?.name || stub.id,
+      frequency: 0,
+      // Placeholder
+      percentage: 0,
+      // Placeholder
+      cardIds: []
+      // Placeholder
+    }));
+    return {
+      distribution,
+      totalTags: tags.length,
+      totalCards: courseInfo.cardCount
+    };
+  } catch (error) {
+    console.error("Error calculating tag distribution:", error);
+    throw new Error(`Failed to calculate tag distribution: ${error instanceof Error ? error.message : "Unknown error"}`);
+  }
+}
+
+// src/resources/index.ts
+var RESOURCE_PATTERNS = {
+  COURSE_CONFIG: "course://config",
+  CARDS_ALL: "cards://all",
+  CARDS_TAG: "cards://tag/{tagName}",
+  CARDS_SHAPE: "cards://shape/{shapeName}",
+  CARDS_ELO: "cards://elo/{eloRange}",
+  SHAPES_ALL: "shapes://all",
+  SHAPES_SPECIFIC: "shapes://{shapeName}",
+  TAGS_ALL: "tags://all",
+  TAGS_STATS: "tags://stats",
+  TAGS_SPECIFIC: "tags://{tagName}",
+  TAGS_UNION: "tags://union/{tags}",
+  TAGS_INTERSECT: "tags://intersect/{tags}",
+  TAGS_EXCLUSIVE: "tags://exclusive/{tags}",
+  TAGS_DISTRIBUTION: "tags://distribution"
+};
+
+// src/types/tools.ts
+var import_zod4 = require("zod");
+var CreateCardInputSchema = import_zod4.z.object({
+  datashape: import_zod4.z.string(),
+  // individual datashapes define their own schema
+  data: import_zod4.z.any(),
+  tags: import_zod4.z.array(import_zod4.z.string()).optional(),
+  elo: import_zod4.z.number().optional(),
+  sourceRef: import_zod4.z.string().optional()
+});
+var UpdateCardInputSchema = import_zod4.z.object({
+  cardId: import_zod4.z.string(),
+  data: import_zod4.z.any().optional(),
+  tags: import_zod4.z.array(import_zod4.z.string()).optional(),
+  elo: import_zod4.z.number().optional(),
+  sourceRef: import_zod4.z.string().optional()
+});
+var TagCardInputSchema = import_zod4.z.object({
+  cardId: import_zod4.z.string(),
+  action: import_zod4.z.enum(["add", "remove"]),
+  tags: import_zod4.z.array(import_zod4.z.string()),
+  updateELO: import_zod4.z.boolean().optional().default(false)
+});
+var DeleteCardInputSchema = import_zod4.z.object({
+  cardId: import_zod4.z.string(),
+  confirm: import_zod4.z.boolean().default(false),
+  reason: import_zod4.z.string().optional()
+});
+
+// src/tools/create-card.ts
+var import_common = require("@vue-skuilder/common");
+async function handleCreateCard(courseDB, input) {
+  const TOOL_NAME = "create_card";
+  try {
+    const validatedInput = CreateCardInputSchema.parse(input);
+    logToolStart(TOOL_NAME, validatedInput);
+    const courseConfig = await courseDB.getCourseConfig();
+    const availableDataShapes = courseConfig.dataShapes.map((ds) => ds.name);
+    if (!availableDataShapes.includes(validatedInput.datashape)) {
+      const errorMsg = `Invalid datashape: ${validatedInput.datashape}. Available: ${availableDataShapes.join(", ")}`;
+      logToolWarning(TOOL_NAME, errorMsg);
+      throw new Error(errorMsg);
+    }
+    const result = await courseDB.addNote(
+      courseConfig.courseID,
+      { name: validatedInput.datashape, fields: [] },
+      validatedInput.data,
+      MCP_AGENT_AUTHOR,
+      validatedInput.tags || [],
+      void 0,
+      // No uploads for now
+      validatedInput.elo ? (0, import_common.toCourseElo)(validatedInput.elo) : void 0
+    );
+    if (result.status !== "ok") {
+      const errorMsg = `Failed to create card: ${result.message || "Unknown error"}`;
+      throw new Error(errorMsg);
+    }
+    const initialElo = validatedInput.elo || 1500;
+    const output = {
+      cardId: result.id || "unknown",
+      initialElo,
+      created: true
+    };
+    logToolSuccess(TOOL_NAME, output);
+    return output;
+  } catch (error) {
+    handleToolError(error, TOOL_NAME);
+  }
+}
+
+// src/tools/update-card.ts
+var import_common2 = require("@vue-skuilder/common");
+async function handleUpdateCard(courseDB, input) {
+  const TOOL_NAME = "update_card";
+  try {
+    const validatedInput = UpdateCardInputSchema.parse(input);
+    logToolStart(TOOL_NAME, validatedInput);
+    const changes = {
+      data: false,
+      tags: false,
+      elo: false,
+      sourceRef: false
+    };
+    try {
+      await courseDB.getCourseDoc(validatedInput.cardId);
+    } catch (error) {
+      throw new Error(`Card not found: ${validatedInput.cardId}`);
+    }
+    if (validatedInput.elo !== void 0) {
+      try {
+        const courseElo = (0, import_common2.toCourseElo)(validatedInput.elo);
+        await courseDB.updateCardElo(validatedInput.cardId, courseElo);
+        changes.elo = true;
+      } catch (error) {
+        logToolWarning(TOOL_NAME, `Failed to update ELO for card ${validatedInput.cardId}`, error);
+        throw new Error(`Failed to update ELO: ${error instanceof Error ? error.message : "Unknown error"}`);
+      }
+    }
+    if (validatedInput.tags !== void 0) {
+      try {
+        const currentTagsResponse = await courseDB.getAppliedTags(validatedInput.cardId);
+        const currentTagNames = currentTagsResponse.rows.map((row) => row.doc?.name).filter(Boolean);
+        const newTags = validatedInput.tags;
+        const tagsToAdd = newTags.filter((tag) => !currentTagNames.includes(tag));
+        const tagsToRemove = currentTagNames.filter((tag) => !newTags.includes(tag));
+        for (const tagName of tagsToAdd) {
+          try {
+            try {
+              await courseDB.getTag(tagName);
+            } catch {
+              await courseDB.createTag(tagName, MCP_AGENT_AUTHOR);
+            }
+            await courseDB.addTagToCard(validatedInput.cardId, tagName);
+          } catch (error) {
+            logToolWarning(TOOL_NAME, `Failed to add tag ${tagName} to card`, error);
+          }
+        }
+        for (const tagName of tagsToRemove) {
+          try {
+            await courseDB.removeTagFromCard(validatedInput.cardId, tagName);
+          } catch (error) {
+            logToolWarning(TOOL_NAME, `Failed to remove tag ${tagName} from card`, error);
+          }
+        }
+        if (tagsToAdd.length > 0 || tagsToRemove.length > 0) {
+          changes.tags = true;
+        }
+      } catch (error) {
+        logToolWarning(TOOL_NAME, `Failed to update tags for card ${validatedInput.cardId}`, error);
+        throw new Error(`Failed to update tags: ${error instanceof Error ? error.message : "Unknown error"}`);
+      }
+    }
+    if (validatedInput.data !== void 0 || validatedInput.sourceRef !== void 0) {
+      logToolWarning(TOOL_NAME, "Data and sourceRef updates are not yet implemented - require direct PouchDB operations");
+    }
+    const updated = changes.elo || changes.tags || changes.data || changes.sourceRef;
+    const output = {
+      cardId: validatedInput.cardId,
+      updated,
+      changes
+    };
+    logToolSuccess(TOOL_NAME, output);
+    return output;
+  } catch (error) {
+    handleToolError(error, TOOL_NAME);
+  }
+}
+
+// src/tools/tag-card.ts
+async function handleTagCard(courseDB, input) {
+  const TOOL_NAME = "tag_card";
+  try {
+    const validatedInput = TagCardInputSchema.parse(input);
+    logToolStart(TOOL_NAME, validatedInput);
+    try {
+      await courseDB.getCourseDoc(validatedInput.cardId);
+    } catch (error) {
+      throw new Error(`Card not found: ${validatedInput.cardId}`);
+    }
+    const tagsProcessed = [];
+    let success = true;
+    for (const tagName of validatedInput.tags) {
+      try {
+        if (validatedInput.action === "add") {
+          try {
+            await courseDB.getTag(tagName);
+          } catch {
+            await courseDB.createTag(tagName, MCP_AGENT_AUTHOR);
+          }
+          await courseDB.addTagToCard(
+            validatedInput.cardId,
+            tagName,
+            validatedInput.updateELO
+          );
+          tagsProcessed.push(tagName);
+        } else if (validatedInput.action === "remove") {
+          await courseDB.removeTagFromCard(validatedInput.cardId, tagName);
+          tagsProcessed.push(tagName);
+        }
+      } catch (error) {
+        logToolWarning(TOOL_NAME, `Failed to ${validatedInput.action} tag ${tagName}`, error);
+        success = false;
+      }
+    }
+    let currentTags = [];
+    try {
+      const currentTagsResponse = await courseDB.getAppliedTags(validatedInput.cardId);
+      currentTags = currentTagsResponse.rows.map((row) => row.doc?.name).filter(Boolean);
+    } catch (error) {
+      logToolWarning(TOOL_NAME, "Failed to fetch current tags", error);
+    }
+    const output = {
+      cardId: validatedInput.cardId,
+      action: validatedInput.action,
+      tagsProcessed,
+      success: success && tagsProcessed.length === validatedInput.tags.length,
+      currentTags
+    };
+    logToolSuccess(TOOL_NAME, output);
+    return output;
+  } catch (error) {
+    handleToolError(error, TOOL_NAME);
+  }
+}
+
+// src/tools/delete-card.ts
+async function handleDeleteCard(courseDB, input) {
+  const TOOL_NAME = "delete_card";
+  try {
+    const validatedInput = DeleteCardInputSchema.parse(input);
+    logToolStart(TOOL_NAME, validatedInput);
+    if (!validatedInput.confirm) {
+      return {
+        cardId: validatedInput.cardId,
+        deleted: false,
+        message: "Card deletion requires explicit confirmation. Set confirm: true to proceed."
+      };
+    }
+    let cardExists = true;
+    try {
+      await courseDB.getCourseDoc(validatedInput.cardId);
+    } catch (error) {
+      cardExists = false;
+    }
+    if (!cardExists) {
+      return {
+        cardId: validatedInput.cardId,
+        deleted: false,
+        message: `Card not found: ${validatedInput.cardId}`
+      };
+    }
+    let cardInfo = "";
+    try {
+      const cardDoc = await courseDB.getCourseDoc(validatedInput.cardId);
+      const cardData = cardDoc;
+      cardInfo = `Card: ${cardData.shape?.name || "unknown shape"}`;
+    } catch (error) {
+      logToolWarning(TOOL_NAME, "Could not fetch card info before deletion", error);
+    }
+    try {
+      const result = await courseDB.removeCard(validatedInput.cardId);
+      if (result.ok) {
+        const reason = validatedInput.reason ? ` Reason: ${validatedInput.reason}` : "";
+        const message = `Card successfully deleted. ${cardInfo}${reason}`;
+        logToolSuccess(TOOL_NAME, `Card deleted: ${validatedInput.cardId}${reason}`);
+        return {
+          cardId: validatedInput.cardId,
+          deleted: true,
+          message
+        };
+      } else {
+        return {
+          cardId: validatedInput.cardId,
+          deleted: false,
+          message: `Failed to delete card: ${result.rev || "Unknown error"}`
+        };
+      }
+    } catch (error) {
+      logToolError(TOOL_NAME, `Error deleting card ${validatedInput.cardId}`, error);
+      return {
+        cardId: validatedInput.cardId,
+        deleted: false,
+        message: `Failed to delete card: ${error instanceof Error ? error.message : "Unknown error"}`
+      };
+    }
+  } catch (error) {
+    handleToolError(error, TOOL_NAME);
+  }
+}
+
+// src/tools/index.ts
+var TOOL_PATTERNS = {
+  CREATE_CARD: "create_card",
+  UPDATE_CARD: "update_card",
+  TAG_CARD: "tag_card",
+  DELETE_CARD: "delete_card"
+};
+
+// src/server.ts
+var import_zod5 = require("zod");
+
+// src/prompts/fill-in-card-authoring.ts
+function createFillInCardAuthoringPrompt() {
+  return `# GUIDE: Authoring "fillIn" type Flashcards
+
+This guide provides the technical specifications for authoring a "fillIn" type flashcard for the Vue-Skuilder platform. When you need to create a new card, you should use the 'create_card' tool and format the content as described below.
+
+## 1. Tool: 'create_card'
+
+You should call the 'create_card' tool with the following parameters:
+
+- 'datashape': Must be 'fillIn'.
+- 'data': A markdown string containing the question and the interactive '{{...}}' elements.
+- 'tags': (Optional) An array of strings for tagging, e.g., ['go', 'concurrency'].
+- 'elo': (Optional) An integer representing the estimated difficulty (e.g., 1250).
+
+**IMPORTANT**: Do NOT include 'tags:' or 'elo:' information inside the 'data' string itself. These are tool parameters.
+
+## 2. Content Formatting ('data' parameter)
+
+The 'data' string is composed of a question and special interactive elements using '{{...}}' syntax.
+
+### A. Simple Fill-in-the-Blank
+- For a single correct answer.
+- **Syntax**: '{{answer}}'
+- **Example**: 'The capital of France is {{Paris}}.'
+
+### B. Fill-in-the-Blank with Alternatives
+- For when multiple text inputs are acceptable for the same blank.
+- **Syntax**: '{{answer1|answer2}}'
+- **Example**: 'A common way to declare a variable in JavaScript that can be reassigned is using the {{let|var}} keyword.'
+
+### C. Multiple Choice
+- For presenting a question with several options.
+- **Syntax**: '{{correct_answer1|correct_answer2||distractor1|distractor2|distractor3|...}}'
+- **Details**:
+    - List one or more correct answers first, separated by '|'.
+    - Use a double pipe '||' to separate correct answers from distractors.
+    - List one or more incorrect answers (distractors) after the '||', separated by '|'.
+    - **Many distractors can be added** - the rendering layer will limit runtime display to a maximum of 5 rendered distractors.
+    - **Front-load the most relevant distractors** - they will be weighted more favorably in selection.
+- **Example (Single Correct)**: 'What is the main gas found in the air we breathe? {{Nitrogen||Oxygen|Carbon Dioxide|Hydrogen}}'
+- **Example (Multiple Correct)**: 'Which of the following are primary colors? {{Red|Blue|Yellow||Green|Orange|Purple}}' (The system will pick one correct answer to display with the distractors).
+- **Example (Many Distractors)**: 'Which letter comes after M in the alphabet? {{N||O|L|P|Q|R|S|T|U|V|W|X|Y|Z|A|B|C|D|E|F|G|H|I|J|K}}' (Only 5 distractors will be shown, with O and L being most likely due to their position).
+
+### D. Overlapping Cards for Difficulty Scaling
+- **It is normal and advisable** to present the same content in overlapping cards with different distractor sets to scale difficulty.
+- **Progressive difficulty**: Start with dissimilar distractors, then increase similarity to make the question harder.
+- **Examples (Spelling/Phonics)**: Given an image of a car:
+    - **Easy**: 'What word matches this image? {{car||airplane}}' (very different options)
+    - **Medium**: 'What word matches this image? {{car||cat}}' (similar sounds)
+    - **Hard**: 'What word matches this image? {{car||care}}' (very similar spelling)
+    - **Harder**: 'What word matches this image? {{car||care|cat|far}}' (multiple similar options)
+- **Benefits**: This approach allows learners to build confidence with easier versions before tackling more challenging variants of the same concept.
+
+## 3. Best Practices & Tips
+
+- **Clarity is Key**: Ensure your questions are clear and the blanks/choices are unambiguous.
+- **Keep Answers Concise**: For fill-in-the-blanks, prefer short, specific answers (1-3 words is ideal). Long answers are hard for users to match. Use multiple-choice for more complex answers.
+- **Code in Questions**: You can and should use markdown code blocks in the question body for context.
+    - **Example**:
+        Given the code:
+        \`\`\`go
+        func main() {
+            x := 10
+            fmt.Println(x)
+        }
+        \`\`\`
+        The above program will {{compile and run correctly||fail at compilation|fail at runtime}}.
+- **Code in Answers**: Code blocks ARE allowed inside the '{{...}}' syntax.
+    - **Example**: '{{\`go\\nfunc main() {\\n    fmt.Println("Hello")\\n}\\n\`}}'
+- **CRITICAL**: Do NOT place the '{{...}}' syntax inside a markdown code block (e.g., \`\`\` ... {{...}} ... \`\`\`). The interactive element must be outside of any code fences.
+- **Review Syntax**: Carefully check your use of '|' and '||' in multiple-choice questions to avoid parsing errors.
+
+## 4. Example Agent Workflow
+
+This is an example of how an agent might use this guide.
+
+**User Request:** "Make a card about Go channels."
+
+**Agent's Thought Process:**
+1.  I need to create a "fillIn" card about Go channels.
+2.  A good multiple-choice question would be about the operator used to send a value to a channel.
+3.  The question will be: "In Go, what operator is used to send a value to a channel?"
+4.  The correct answer is '<-'. Some good distractors would be '->', '<<', and '>>'.
+5.  The 'data' string for the tool call will be: 'In Go, what operator is used to send a value to a channel? {{<-||->|<<|>>}}'
+6.  I'll tag it with 'go' and 'channels'.
+7.  This is a fundamental concept, so I'll give it an ELO of 1100.
+8.  Now I will call the 'create_card' tool with these parameters.
+
+**Resulting Tool Call:**
+<tool_code>
+print(default_api.create_card(
+  datashape='fillIn',
+  data='In Go, what operator is used to send a value to a channel? {{<-||->|<<|>>}}',
+  tags=['go', 'channels'],
+  elo=1100
+))
+</tool_code>`;
+}
+
+// src/prompts/elo-scoring-guidance.ts
+function createEloScoringGuidancePrompt() {
+  return `# GUIDE: ELO Scoring for Content
+
+This guide provides guidance for agents on assigning ELO ratings to content. The ELO system helps provide initial difficulty sorting for new content.
+
+## Understanding ELO Ratings
+
+ELO ratings use a chess-like rating scale to indicate content difficulty:
+
+- **100-500**: Beginner level, basic knowledge
+- **500-1000**: Some knowledge, early understanding
+- **1000-1500**: Intermediate knowledge
+- **1500-2000**: Advanced understanding
+- **2000-2400**: Expert level
+- **2400+**: Elite/master level
+
+## Key Principles
+
+### 1. Rough Initial Sorting
+- Your ELO assignments provide **rough, sane sorting** of new content
+- Aim for reasonable relative difficulty between cards, not perfect precision
+- The system will refine these ratings over time based on real-world performance
+
+### 2. Automated Refinement
+- The platform performs **automated realtime adjustment** of ELO ratings based on actual user performance
+- This convergence forcing function holds **most of the responsibility** for arranging relative difficulty
+- Your initial ratings serve as a starting point, not the final word
+
+### 3. Content-Based Guidelines
+
+#### Basic Knowledge (100-500)
+- Simple facts and definitions
+- Basic vocabulary
+- Elementary concepts
+- **Example**: "The capital of France is {{Paris}}"
+
+#### Early Understanding (500-1000)
+- Simple applications of concepts
+- Basic problem-solving
+- Common patterns and rules
+- **Example**: "In JavaScript, use {{let|var}} to declare a reassignable variable"
+
+#### Intermediate Knowledge (1000-1500)
+- More complex applications
+- Understanding relationships between concepts
+- Moderate problem-solving skills
+- **Example**: "Which sorting algorithm has O(n log n) average time complexity? {{mergesort|heapsort||bubblesort|insertionsort}}"
+
+#### Advanced Understanding (1500-2000)
+- Complex problem-solving
+- Deep conceptual understanding
+- Advanced techniques and patterns
+- **Example**: "In Go, what happens when you close a channel that's already closed? {{runtime panic||returns false|blocks forever|does nothing}}"
+
+#### Expert Level (2000-2400)
+- Specialized knowledge
+- Advanced edge cases
+- Professional-level understanding
+- **Example**: "What's the difference between TCP_NODELAY and TCP_CORK socket options?"
+
+#### Elite/Master Level (2400+)
+- Cutting-edge knowledge
+- Rare edge cases
+- Research-level understanding
+- **Example**: "How does the Linux kernel's CFS scheduler handle nice values in relation to vruntime calculations?"
+
+## Practical Application
+
+### When Assigning ELO Ratings:
+
+1. **Consider the target audience**: Who would reasonably be expected to know this?
+2. **Assess cognitive load**: How much thinking/reasoning is required?
+3. **Evaluate prerequisite knowledge**: What must someone know first?
+4. **Compare relatively**: Is this harder or easier than other cards on similar topics?
+
+### Common Patterns:
+
+- **Definitions and facts**: Usually 100-800
+- **Basic syntax/usage**: Usually 400-1200
+- **Concept application**: Usually 800-1600
+- **Problem-solving**: Usually 1200-2000
+- **Advanced techniques**: Usually 1600-2400+
+
+## Establishing Goalposts for Agentic Runs
+
+### Reference Live Course Data
+When appending data to existing courses, try to use existing data to understand the baseline against which we create. ELO is relative and not absolute.
+
+1. **Query existing course statistics** using available MCP resources:
+   - \`course://config\` - Get overall course ELO distribution
+   - \`tags://stats\` - Understand tag usage patterns
+   - \`cards://elo/{range}\` - Sample cards in different difficulty ranges
+
+2. **Establish relative ranges** based on existing content:
+   - If the course has cards ranging 800-1600, aim for similar distribution
+   - If creating beginner content for an advanced course, adjust baseline accordingly
+   - Use tag-specific ELO patterns to inform ratings for similar topics
+
+### Example Goalpost Process
+\`\`\`
+1. Query: cards://elo/1000-1500 (check intermediate range)
+2. Observe: 23 cards average 1250 ELO on "javascript" tag
+3. Target: New JavaScript cards should cluster around 1200-1300
+4. Create: Cards with relative difficulty within established range
+\`\`\`
+
+## Remember
+
+- **It's okay to be approximate** - the system will adjust based on real performance
+- **Consistency matters more than perfection** - try to be consistent within topic areas
+- **Focus on relative difficulty** - how does this compare to other cards you've created? re: factual content - specialization matters - more esoteric knowledge should be rated higher
+- **Use live data as your anchor** - let existing course content guide your rating decisions
+
+Your ELO assignments provide the initial scaffolding that allows the platform's adaptive algorithms to efficiently converge on optimal difficulty ratings.`;
+}
+
+// src/prompts/index.ts
+var PROMPT_PATTERNS = {
+  FILL_IN_CARD_AUTHORING: "fill-in-card-authoring",
+  ELO_SCORING_GUIDANCE: "elo-scoring-guidance"
+};
+
+// src/server.ts
+var MCPServer = class {
+  constructor(courseDB, options = {}) {
+    this.courseDB = courseDB;
+    this.options = options;
+    this.mcpServer = new import_mcp.McpServer({
+      name: "vue-skuilder-mcp",
+      version: "0.1.0"
+    });
+    this.setupCapabilities();
+  }
+  mcpServer;
+  transport;
+  setupCapabilities() {
+    this.mcpServer.registerResource(
+      RESOURCE_PATTERNS.COURSE_CONFIG,
+      RESOURCE_PATTERNS.COURSE_CONFIG,
+      {
+        title: "Course Configuration",
+        description: "Course configuration with metadata and ELO statistics",
+        mimeType: "application/json"
+      },
+      async (uri) => {
+        const result = await handleCourseConfigResource(this.courseDB);
+        return {
+          contents: [
+            {
+              uri: uri.href,
+              text: JSON.stringify(result, null, 2),
+              mimeType: "application/json"
+            }
+          ]
+        };
+      }
+    );
+    this.mcpServer.registerResource(
+      RESOURCE_PATTERNS.CARDS_ALL,
+      RESOURCE_PATTERNS.CARDS_ALL,
+      {
+        title: "All Course Cards",
+        description: "List all cards in the course with pagination support",
+        mimeType: "application/json"
+      },
+      async (uri) => {
+        const url = new URL(uri.href);
+        const limit = parseInt(url.searchParams.get("limit") || "50", 10);
+        const offset = parseInt(url.searchParams.get("offset") || "0", 10);
+        const result = await handleCardsAllResource(this.courseDB, limit, offset);
+        return {
+          contents: [
+            {
+              uri: uri.href,
+              text: JSON.stringify(result, null, 2),
+              mimeType: "application/json"
+            }
+          ]
+        };
+      }
+    );
+    this.mcpServer.registerResource(
+      RESOURCE_PATTERNS.CARDS_TAG,
+      new import_mcp.ResourceTemplate("cards://tag/{tagName}", { list: void 0 }),
+      {
+        title: "Cards by Tag",
+        description: "Filter cards by tag name with pagination support",
+        mimeType: "application/json"
+      },
+      async (uri, { tagName }) => {
+        const url = new URL(uri.href);
+        const limit = parseInt(url.searchParams.get("limit") || "50", 10);
+        const offset = parseInt(url.searchParams.get("offset") || "0", 10);
+        const result = await handleCardsTagResource(
+          this.courseDB,
+          tagName,
+          limit,
+          offset
+        );
+        return {
+          contents: [
+            {
+              uri: uri.href,
+              text: JSON.stringify(result, null, 2),
+              mimeType: "application/json"
+            }
+          ]
+        };
+      }
+    );
+    this.mcpServer.registerResource(
+      RESOURCE_PATTERNS.CARDS_SHAPE,
+      new import_mcp.ResourceTemplate("cards://shape/{shapeName}", { list: void 0 }),
+      {
+        title: "Cards by DataShape",
+        description: "Filter cards by DataShape with pagination support",
+        mimeType: "application/json"
+      },
+      async (uri, { shapeName }) => {
+        const url = new URL(uri.href);
+        const limit = parseInt(url.searchParams.get("limit") || "50", 10);
+        const offset = parseInt(url.searchParams.get("offset") || "0", 10);
+        const result = await handleCardsShapeResource(
+          this.courseDB,
+          shapeName,
+          limit,
+          offset
+        );
+        return {
+          contents: [
+            {
+              uri: uri.href,
+              text: JSON.stringify(result, null, 2),
+              mimeType: "application/json"
+            }
+          ]
+        };
+      }
+    );
+    this.mcpServer.registerResource(
+      RESOURCE_PATTERNS.CARDS_ELO,
+      new import_mcp.ResourceTemplate("cards://elo/{eloRange}", { list: void 0 }),
+      {
+        title: "Cards by ELO Range",
+        description: "Filter cards by ELO range (format: min-max, e.g., 1200-1800)",
+        mimeType: "application/json"
+      },
+      async (uri, { eloRange }) => {
+        const url = new URL(uri.href);
+        const limit = parseInt(url.searchParams.get("limit") || "50", 10);
+        const offset = parseInt(url.searchParams.get("offset") || "0", 10);
+        const result = await handleCardsEloResource(
+          this.courseDB,
+          eloRange,
+          limit,
+          offset
+        );
+        return {
+          contents: [
+            {
+              uri: uri.href,
+              text: JSON.stringify(result, null, 2),
+              mimeType: "application/json"
+            }
+          ]
+        };
+      }
+    );
+    this.mcpServer.registerResource(
+      RESOURCE_PATTERNS.SHAPES_ALL,
+      RESOURCE_PATTERNS.SHAPES_ALL,
+      {
+        title: "All DataShapes",
+        description: "List all available DataShapes in the course",
+        mimeType: "application/json"
+      },
+      async (uri) => {
+        const result = await handleShapesAllResource(this.courseDB);
+        return {
+          contents: [
+            {
+              uri: uri.href,
+              text: JSON.stringify(result, null, 2),
+              mimeType: "application/json"
+            }
+          ]
+        };
+      }
+    );
+    this.mcpServer.registerResource(
+      RESOURCE_PATTERNS.SHAPES_SPECIFIC,
+      new import_mcp.ResourceTemplate("shapes://{shapeName}", { list: void 0 }),
+      {
+        title: "Specific DataShape",
+        description: "Get detailed information about a specific DataShape",
+        mimeType: "application/json"
+      },
+      async (uri, { shapeName }) => {
+        const result = await handleShapeSpecificResource(this.courseDB, shapeName);
+        return {
+          contents: [
+            {
+              uri: uri.href,
+              text: JSON.stringify(result, null, 2),
+              mimeType: "application/json"
+            }
+          ]
+        };
+      }
+    );
+    this.mcpServer.registerResource(
+      RESOURCE_PATTERNS.TAGS_ALL,
+      RESOURCE_PATTERNS.TAGS_ALL,
+      {
+        title: "All Tags",
+        description: "List all available tags in the course",
+        mimeType: "application/json"
+      },
+      async (uri) => {
+        const result = await handleTagsAllResource(this.courseDB);
+        return {
+          contents: [
+            {
+              uri: uri.href,
+              text: JSON.stringify(result, null, 2),
+              mimeType: "application/json"
+            }
+          ]
+        };
+      }
+    );
+    this.mcpServer.registerResource(
+      RESOURCE_PATTERNS.TAGS_STATS,
+      RESOURCE_PATTERNS.TAGS_STATS,
+      {
+        title: "Tag Statistics",
+        description: "Get usage statistics for tags in the course",
+        mimeType: "application/json"
+      },
+      async (uri) => {
+        const result = await handleTagsStatsResource(this.courseDB);
+        return {
+          contents: [
+            {
+              uri: uri.href,
+              text: JSON.stringify(result, null, 2),
+              mimeType: "application/json"
+            }
+          ]
+        };
+      }
+    );
+    this.mcpServer.registerResource(
+      RESOURCE_PATTERNS.TAGS_SPECIFIC,
+      new import_mcp.ResourceTemplate("tags://{tagName}", { list: void 0 }),
+      {
+        title: "Specific Tag",
+        description: "Get detailed information about a specific tag",
+        mimeType: "application/json"
+      },
+      async (uri, { tagName }) => {
+        const result = await handleTagSpecificResource(this.courseDB, tagName);
+        return {
+          contents: [
+            {
+              uri: uri.href,
+              text: JSON.stringify(result, null, 2),
+              mimeType: "application/json"
+            }
+          ]
+        };
+      }
+    );
+    this.mcpServer.registerResource(
+      RESOURCE_PATTERNS.TAGS_UNION,
+      new import_mcp.ResourceTemplate("tags://union/{tags}", { list: void 0 }),
+      {
+        title: "Tags Union",
+        description: "Find cards with ANY of the specified tags (format: tag1+tag2)",
+        mimeType: "application/json"
+      },
+      async (uri, { tags }) => {
+        const result = await handleTagsUnionResource(this.courseDB, tags);
+        return {
+          contents: [
+            {
+              uri: uri.href,
+              text: JSON.stringify(result, null, 2),
+              mimeType: "application/json"
+            }
+          ]
+        };
+      }
+    );
+    this.mcpServer.registerResource(
+      RESOURCE_PATTERNS.TAGS_INTERSECT,
+      new import_mcp.ResourceTemplate("tags://intersect/{tags}", { list: void 0 }),
+      {
+        title: "Tags Intersect",
+        description: "Find cards with ALL of the specified tags (format: tag1+tag2)",
+        mimeType: "application/json"
+      },
+      async (uri, { tags }) => {
+        const result = await handleTagsIntersectResource(this.courseDB, tags);
+        return {
+          contents: [
+            {
+              uri: uri.href,
+              text: JSON.stringify(result, null, 2),
+              mimeType: "application/json"
+            }
+          ]
+        };
+      }
+    );
+    this.mcpServer.registerResource(
+      RESOURCE_PATTERNS.TAGS_EXCLUSIVE,
+      new import_mcp.ResourceTemplate("tags://exclusive/{tags}", { list: void 0 }),
+      {
+        title: "Tags Exclusive",
+        description: "Find cards with first tag but NOT second tag (format: tag1-tag2)",
+        mimeType: "application/json"
+      },
+      async (uri, { tags }) => {
+        const result = await handleTagsExclusiveResource(this.courseDB, tags);
+        return {
+          contents: [
+            {
+              uri: uri.href,
+              text: JSON.stringify(result, null, 2),
+              mimeType: "application/json"
+            }
+          ]
+        };
+      }
+    );
+    this.mcpServer.registerResource(
+      RESOURCE_PATTERNS.TAGS_DISTRIBUTION,
+      RESOURCE_PATTERNS.TAGS_DISTRIBUTION,
+      {
+        title: "Tag Distribution",
+        description: "Get frequency distribution of all tags in the course",
+        mimeType: "application/json"
+      },
+      async (uri) => {
+        const result = await handleTagsDistributionResource(this.courseDB);
+        return {
+          contents: [
+            {
+              uri: uri.href,
+              text: JSON.stringify(result, null, 2),
+              mimeType: "application/json"
+            }
+          ]
+        };
+      }
+    );
+    this.mcpServer.registerTool(
+      TOOL_PATTERNS.CREATE_CARD,
+      {
+        title: "Create Card",
+        description: "Create a new course card with specified datashape and content",
+        inputSchema: {
+          datashape: import_zod5.z.string(),
+          data: import_zod5.z.any(),
+          tags: import_zod5.z.array(import_zod5.z.string()).optional(),
+          elo: import_zod5.z.number().optional(),
+          sourceRef: import_zod5.z.string().optional()
+        }
+      },
+      async (input) => {
+        const result = await handleCreateCard(this.courseDB, input);
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify(result, null, 2)
+            }
+          ]
+        };
+      }
+    );
+    this.mcpServer.registerTool(
+      TOOL_PATTERNS.UPDATE_CARD,
+      {
+        title: "Update Card",
+        description: "Update an existing course card (data, tags, ELO, sourceRef)",
+        inputSchema: {
+          cardId: import_zod5.z.string(),
+          data: import_zod5.z.any().optional(),
+          tags: import_zod5.z.array(import_zod5.z.string()).optional(),
+          elo: import_zod5.z.number().optional(),
+          sourceRef: import_zod5.z.string().optional()
+        }
+      },
+      async (input) => {
+        const result = await handleUpdateCard(this.courseDB, input);
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify(result, null, 2)
+            }
+          ]
+        };
+      }
+    );
+    this.mcpServer.registerTool(
+      TOOL_PATTERNS.TAG_CARD,
+      {
+        title: "Tag Card",
+        description: "Add or remove tags from a course card with optional ELO update",
+        inputSchema: {
+          cardId: import_zod5.z.string(),
+          action: import_zod5.z.enum(["add", "remove"]),
+          tags: import_zod5.z.array(import_zod5.z.string()),
+          updateELO: import_zod5.z.boolean().optional().default(false)
+        }
+      },
+      async (input) => {
+        const result = await handleTagCard(this.courseDB, input);
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify(result, null, 2)
+            }
+          ]
+        };
+      }
+    );
+    this.mcpServer.registerTool(
+      TOOL_PATTERNS.DELETE_CARD,
+      {
+        title: "Delete Card",
+        description: "Safely delete a course card with confirmation requirement",
+        inputSchema: {
+          cardId: import_zod5.z.string(),
+          confirm: import_zod5.z.boolean().default(false),
+          reason: import_zod5.z.string().optional()
+        }
+      },
+      async (input) => {
+        const result = await handleDeleteCard(this.courseDB, input);
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify(result, null, 2)
+            }
+          ]
+        };
+      }
+    );
+    this.mcpServer.registerPrompt(
+      PROMPT_PATTERNS.FILL_IN_CARD_AUTHORING,
+      {
+        title: "Author Fill-In Card",
+        description: "Generate a fill-in-the-blank or multiple-choice card using Vue-Skuilder syntax.",
+        argsSchema: {}
+      },
+      () => ({
+        messages: [
+          {
+            role: "user",
+            content: {
+              type: "text",
+              text: createFillInCardAuthoringPrompt()
+            }
+          }
+        ]
+      })
+    );
+    this.mcpServer.registerPrompt(
+      PROMPT_PATTERNS.ELO_SCORING_GUIDANCE,
+      {
+        title: "ELO Scoring Guidance",
+        description: "Guidance for assigning ELO difficulty ratings to flashcard content.",
+        argsSchema: {}
+      },
+      () => ({
+        messages: [
+          {
+            role: "user",
+            content: {
+              type: "text",
+              text: createEloScoringGuidancePrompt()
+            }
+          }
+        ]
+      })
+    );
+    if (this.options.enableSourceLinking) {
+    }
+  }
+  async start(transport) {
+    this.transport = transport;
+    await this.mcpServer.connect(transport);
+  }
+  async stop() {
+    if (this.transport) {
+      await this.transport.close();
+    }
+    await this.mcpServer.close();
+  }
+  // Getter for accessing the underlying MCP server (for testing)
+  get server() {
+    return this.mcpServer;
+  }
+  // Getter for accessing the course database
+  get courseDatabase() {
+    return this.courseDB;
+  }
+};
+
+// src/examples/local-dev.ts
+var import_db = require("@vue-skuilder/db");
+var import_stdio = require("@modelcontextprotocol/sdk/server/stdio.js");
+var TEST_COURSE_ID = "2aeb8315ef78f3e89ca386992d00825b";
+async function main() {
+  try {
+    console.error("Starting Vue-Skuilder MCP Server...");
+    console.error(`Using test course: ${TEST_COURSE_ID}`);
+    await (0, import_db.initializeDataLayer)({
+      options: {
+        COUCHDB_PASSWORD: "password",
+        COUCHDB_USERNAME: "admin",
+        COUCHDB_SERVER_PROTOCOL: "http",
+        COUCHDB_SERVER_URL: "localhost:5984"
+      },
+      type: "couch"
+    });
+    const dataLayer = (0, import_db.getDataLayer)();
+    await dataLayer.initialize();
+    const courseDB = dataLayer.getCourseDB(TEST_COURSE_ID);
+    const server = new MCPServer(courseDB, {
+      enableSourceLinking: true,
+      maxCardsPerQuery: 50
+    });
+    const transport = new import_stdio.StdioServerTransport();
+    await server.start(transport);
+    console.error("MCP Server started successfully!");
+    console.error("Resources available: course://config");
+    console.error("Tools available: create_card");
+  } catch (error) {
+    console.error("Failed to start MCP server:", error);
+    process.exit(1);
+  }
+}
+main().catch(console.error);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  CourseConfigUriSchema,
+  CreateCardInputSchema,
+  DeleteCardInputSchema,
+  MCPServer,
+  RESOURCE_PATTERNS,
+  TOOL_PATTERNS,
+  TagCardInputSchema,
+  UpdateCardInputSchema,
+  handleCardsAllResource,
+  handleCardsEloResource,
+  handleCardsShapeResource,
+  handleCardsTagResource,
+  handleCourseConfigResource,
+  handleCreateCard,
+  handleDeleteCard,
+  handleShapeSpecificResource,
+  handleShapesAllResource,
+  handleTagCard,
+  handleTagSpecificResource,
+  handleTagsAllResource,
+  handleTagsDistributionResource,
+  handleTagsExclusiveResource,
+  handleTagsIntersectResource,
+  handleTagsStatsResource,
+  handleTagsUnionResource,
+  handleUpdateCard
+});
+//# sourceMappingURL=index.js.map