@vue-skuilder/cli 0.1.11-9 → 0.1.12

package/src/commands/studio.ts

@@ -57,7 +57,7 @@ export function createStudioCommand(): Command {
     .description(
       'Launch studio mode: a complete course editing environment with CouchDB, Express API, and web editor'
     )
-    .argument('[coursePath]', 'Path to static course directory', '.')
+    .argument('[coursePath]', 'Path to static course directory or manifest file', '.')
     .option('-p, --port <port>', 'CouchDB port for studio session', '5985')
     .option('--no-browser', 'Skip automatic browser launch')
     .action(launchStudio)
@@ -79,8 +79,11 @@ Studio Mode creates a full editing environment for static courses:
 
   Requirements:
     • Docker (for CouchDB instance)
-    • Valid static course project (with package.json)
-    • Course data in public/static-courses/ directory
+    - either
+      • Valid static course project (with package.json)
+      • Course data in public/static-courses/ directory
+    - OR
+      - a valid mainfest.json
 
   Example:
     skuilder studio                    # Launch in current directory
@@ -104,94 +107,63 @@ async function launchStudio(coursePath: string, options: StudioOptions) {
   try {
     console.log(chalk.cyan(`🎨 Launching Skuilder Studio...`));
 
-    // Phase 2: Course Detection & Validation
+    // Input validation and course detection
     const resolvedPath = path.resolve(coursePath);
-    console.log(chalk.gray(`📁 Course path: ${resolvedPath}`));
-
-    if (!(await validateSuiCourse(resolvedPath))) {
-      console.error(chalk.red(`❌ Not a valid standalone-ui course directory`));
-      console.log(chalk.yellow(`💡 Studio mode requires a vue-skuilder course with:`));
-      console.log(chalk.yellow(`   - package.json with @vue-skuilder/* dependencies`));
-      console.log(
-        chalk.yellow(`   - static-data/ OR public/static-courses/ directory with course content`)
-      );
-      process.exit(1);
-    }
-
-    console.log(chalk.green(`✅ Valid standalone-ui course detected`));
-
-    // Phase 0.5: Hash questions directory to determine studio-ui build needs
-    console.log(chalk.cyan(`🔍 Analyzing local question types...`));
-    let questionsHash: string;
-    let studioUIPath: string;
-
-    try {
-      questionsHash = await withStudioBuildErrorHandling(
-        () => hashQuestionsDirectory(resolvedPath),
-        StudioBuildErrorType.QUESTIONS_HASH_ERROR,
-        { coursePath: resolvedPath }
-      );
-
-      // Ensure cache directory exists
-      await ensureCacheDirectory(resolvedPath);
-
-      const buildExists = studioBuildExists(resolvedPath, questionsHash);
-      const buildPath = getStudioBuildPath(resolvedPath, questionsHash);
-
-      console.log(chalk.gray(`   Questions hash: ${questionsHash}`));
-      console.log(chalk.gray(`   Cached build exists: ${buildExists ? 'Yes' : 'No'}`));
-
-      // Determine if we need to rebuild studio-ui
-      if (buildExists) {
-        console.log(chalk.gray(`   Using cached build at: ${buildPath}`));
-        studioUIPath = buildPath;
-      } else {
-        console.log(chalk.cyan(`🔨 Building studio-ui with local question types...`));
-        studioUIPath = await buildStudioUIWithQuestions(resolvedPath, questionsHash);
-        console.log(chalk.green(`✅ Studio-UI build complete: ${studioUIPath}`));
-      }
-    } catch (error) {
-      // Handle catastrophic build errors by falling back to embedded source
-      console.log(
-        chalk.yellow(
-          `⚠️  Unable to process questions due to ${error},\n⚠️  Using embedded studio-ui`
-        )
-      );
-
-      const embeddedPath = path.join(__dirname, '..', 'studio-ui-src');
-
-      if (fs.existsSync(embeddedPath)) {
-        studioUIPath = embeddedPath;
-        console.log(chalk.gray(`   Using embedded studio-ui source directly`));
-      } else {
-        console.error(chalk.red(`❌ No viable studio-ui source available`));
-        throw new Error('Critical error: Cannot locate studio-ui source');
+    console.log(chalk.gray(`📁 Input path: ${resolvedPath}`));
+
+    let isManifestMode = false;
+    let actualCoursePath = resolvedPath;
+
+    // Check if input is a manifest file
+    const manifestValidation = await validateManifestCourse(resolvedPath);
+    if (manifestValidation.isValid) {
+      console.log(chalk.green(`✅ Valid course manifest detected`));
+      isManifestMode = true;
+      actualCoursePath = manifestValidation.coursePath!;
+      console.log(chalk.gray(`📁 Course data path: ${actualCoursePath}`));
+    } else {
+      // Check if it's a traditional scaffolded course directory
+      if (!(await validateSuiCourse(resolvedPath))) {
+        console.error(chalk.red(`❌ Not a valid course directory or manifest file`));
+        console.log(chalk.yellow(`💡 Studio mode accepts either:`));
+        console.log(
+          chalk.yellow(`   - Scaffolded course directory with package.json and static-data/`)
+        );
+        console.log(
+          chalk.yellow(`   - Course manifest.json file with chunks/ and indices/ directories`)
+        );
+        process.exit(1);
       }
+      console.log(chalk.green(`✅ Valid standalone-ui course detected`));
     }
 
-    // Phase 1: CouchDB Management
-    const studioDatabaseName = generateStudioDatabaseName(resolvedPath);
+    // Studio UI build preparation
+    const studioUIPath = isManifestMode
+      ? await handleManifestCourse()
+      : await handleSuiCourse(resolvedPath);
+
+    // Start CouchDB instance
+    const studioDatabaseName = generateStudioDatabaseName(actualCoursePath);
     console.log(chalk.cyan(`🗄️  Starting studio CouchDB instance: ${studioDatabaseName}`));
 
     couchDBManager = await startStudioCouchDB(studioDatabaseName, parseInt(options.port));
 
-    // Phase 4: Populate CouchDB with course data
+    // Load course data into database
     console.log(chalk.cyan(`📦 Unpacking course data to studio database...`));
     const unpackResult = await unpackCourseToStudio(
-      resolvedPath,
-      couchDBManager.getConnectionDetails()
+      actualCoursePath,
+      couchDBManager.getConnectionDetails(),
+      isManifestMode
     );
 
-    // Phase 9.5: Launch Express backend
-    console.log(chalk.cyan(`⚡ Starting Express backend server...`));
+    // Start Express API server
     const expressResult = await startExpressBackend(
       couchDBManager.getConnectionDetails(),
-      resolvedPath,
       unpackResult.databaseName
     );
     expressServer = expressResult.server;
 
-    // Phase 7: Launch studio-ui server
+    // Launch studio web interface
     console.log(chalk.cyan(`🌐 Starting studio-ui server...`));
     console.log(
       chalk.gray(
@@ -201,7 +173,8 @@ async function launchStudio(coursePath: string, options: StudioOptions) {
     const studioUIPort = await startStudioUIServer(
       couchDBManager.getConnectionDetails(),
       unpackResult,
-      studioUIPath
+      studioUIPath,
+      expressResult.url
     );
 
     console.log(chalk.green(`✅ Studio session ready!`));
@@ -210,7 +183,7 @@ async function launchStudio(coursePath: string, options: StudioOptions) {
     console.log(chalk.gray(`   Express API: ${expressResult.url}`));
 
     // Display MCP connection information
-    const mcpInfo = getMCPConnectionInfo(unpackResult, couchDBManager, resolvedPath);
+    const mcpInfo = getMCPConnectionInfo(unpackResult, couchDBManager);
     console.log(chalk.blue(`🔗 MCP Server: ${mcpInfo.command}`));
     console.log(chalk.gray(`   Connect MCP clients using the command above`));
     console.log(chalk.gray(`   Environment variables for MCP:`));
@@ -219,7 +192,7 @@ async function launchStudio(coursePath: string, options: StudioOptions) {
     });
 
     // Display .mcp.json content for Claude Code integration
-    const mcpJsonContent = generateMCPJson(unpackResult, couchDBManager, resolvedPath);
+    const mcpJsonContent = generateMCPJson(unpackResult, couchDBManager);
     console.log(chalk.blue(`📋 .mcp.json content:`));
     console.log(chalk.gray(mcpJsonContent));
 
@@ -229,7 +202,7 @@ async function launchStudio(coursePath: string, options: StudioOptions) {
     }
     console.log(chalk.gray(`   Press Ctrl+C to stop studio session`));
 
-    // Keep process alive and handle cleanup
+    // Session lifecycle management
     process.on('SIGINT', () => {
       void (async () => {
         console.log(chalk.cyan(`\n🔄 Stopping studio session...`));
@@ -256,7 +229,50 @@ async function launchStudio(coursePath: string, options: StudioOptions) {
 }
 
 /**
- * Phase 2: Validate that the given path contains a standalone-ui course
+ * Validate that the given path is a course manifest file
+ */
+async function validateManifestCourse(
+  manifestPath: string
+): Promise<{ isValid: boolean; coursePath?: string }> {
+  try {
+    // Check if file exists
+    if (!fs.existsSync(manifestPath) || !fs.statSync(manifestPath).isFile()) {
+      return { isValid: false };
+    }
+
+    // Check if it's a JSON file
+    if (!manifestPath.endsWith('.json')) {
+      return { isValid: false };
+    }
+
+    // Try to parse as JSON
+    const manifestContent = JSON.parse(fs.readFileSync(manifestPath, 'utf-8'));
+
+    // Validate required manifest fields
+    if (!manifestContent.courseId || !manifestContent.courseName) {
+      return { isValid: false };
+    }
+
+    // Find course data directory relative to manifest
+    const manifestDir = path.dirname(manifestPath);
+    const coursePath = manifestDir; // Course data should be alongside manifest
+
+    // Check for required course data structure
+    const chunksPath = path.join(coursePath, 'chunks');
+    const indicesPath = path.join(coursePath, 'indices');
+
+    if (!fs.existsSync(chunksPath) || !fs.existsSync(indicesPath)) {
+      return { isValid: false };
+    }
+
+    return { isValid: true, coursePath };
+  } catch {
+    return { isValid: false };
+  }
+}
+
+/**
+ * Validate that the given path contains a standalone-ui course
  */
 async function validateSuiCourse(coursePath: string): Promise<boolean> {
   try {
@@ -407,7 +423,8 @@ interface UnpackResult {
 async function startStudioUIServer(
   connectionDetails: ConnectionDetails,
   unpackResult: UnpackResult,
-  studioPath: string
+  studioPath: string,
+  expressApiUrl?: string
 ): Promise<number> {
   // Serve from built dist directory if it exists, otherwise fallback to source
   const distPath = path.join(studioPath, 'dist');
@@ -458,6 +475,9 @@ async function startStudioUIServer(
                     name: '${unpackResult.databaseName}',
                     courseId: '${unpackResult.courseId}',
                     originalCourseId: '${unpackResult.courseId}'
+                  },
+                  express: {
+                    url: '${expressApiUrl || 'http://localhost:3000'}'
                   }
                 };
               </script>
@@ -486,6 +506,9 @@ async function startStudioUIServer(
                     name: '${unpackResult.databaseName}',
                     courseId: '${unpackResult.courseId}',
                     originalCourseId: '${unpackResult.courseId}'
+                  },
+                  express: {
+                    url: '${expressApiUrl || 'http://localhost:3000'}'
                   }
                 };
               </script>
@@ -562,7 +585,6 @@ async function openBrowser(url: string): Promise<void> {
  */
 async function startExpressBackend(
   couchDbConnectionDetails: ConnectionDetails,
-  _projectPath: string,
   databaseName: string
 ): Promise<{ server: http.Server; port: number; url: string }> {
   console.log(chalk.blue('⚡ Starting Express backend server...'));
@@ -594,6 +616,9 @@ async function startExpressBackend(
   };
 
   try {
+    // Set NODE_ENV for studio mode authentication bypass
+    process.env.NODE_ENV = 'studio';
+
     // Create Express app using factory
     const app = createExpressApp(config);
 
@@ -624,28 +649,37 @@ async function startExpressBackend(
  */
 async function unpackCourseToStudio(
   coursePath: string,
-  connectionDetails: ConnectionDetails
+  connectionDetails: ConnectionDetails,
+  isManifestMode = false
 ): Promise<{ databaseName: string; courseId: string }> {
   try {
-    // Find the course data directory (static-data OR public/static-courses)
-    let courseDataPath = path.join(coursePath, 'static-data');
-    if (!fs.existsSync(courseDataPath)) {
-      // Try public/static-courses directory
-      const publicStaticPath = path.join(coursePath, 'public', 'static-courses');
-      if (fs.existsSync(publicStaticPath)) {
-        // Find the first course directory inside public/static-courses
-        const courses = fs
-          .readdirSync(publicStaticPath, { withFileTypes: true })
-          .filter((dirent) => dirent.isDirectory())
-          .map((dirent) => dirent.name);
-
-        if (courses.length > 0) {
-          courseDataPath = path.join(publicStaticPath, courses[0]);
+    let courseDataPath: string;
+
+    if (isManifestMode) {
+      // For manifest mode, the coursePath already points to the course data directory
+      courseDataPath = coursePath;
+      console.log(chalk.gray(`   Manifest mode: using course data at ${courseDataPath}`));
+    } else {
+      // Find the course data directory (static-data OR public/static-courses)
+      courseDataPath = path.join(coursePath, 'static-data');
+      if (!fs.existsSync(courseDataPath)) {
+        // Try public/static-courses directory
+        const publicStaticPath = path.join(coursePath, 'public', 'static-courses');
+        if (fs.existsSync(publicStaticPath)) {
+          // Find the first course directory inside public/static-courses
+          const courses = fs
+            .readdirSync(publicStaticPath, { withFileTypes: true })
+            .filter((dirent) => dirent.isDirectory())
+            .map((dirent) => dirent.name);
+
+          if (courses.length > 0) {
+            courseDataPath = path.join(publicStaticPath, courses[0]);
+          } else {
+            throw new Error('No course directories found in public/static-courses/');
+          }
         } else {
-          throw new Error('No course directories found in public/static-courses/');
+          throw new Error('No course data found in static-data/ or public/static-courses/');
         }
-      } else {
-        throw new Error('No course data found in static-data/ or public/static-courses/');
       }
     }
 
@@ -836,9 +870,9 @@ async function buildDefaultStudioUI(buildPath: string): Promise<string> {
     const studioPackageJsonPath = path.join(buildPath, 'package.json');
     await transformPackageJsonForStudioBuild(studioPackageJsonPath);
 
-    // Fix Vite config to use npm packages instead of monorepo paths
-    console.log(chalk.gray(`   Updating Vite configuration for standalone build...`));
-    await fixViteConfigForStandaloneBuild(buildPath);
+    // Fix Vite config to use npm packages and resolve custom questions imports
+    console.log(chalk.gray(`   Updating Vite configuration for studio build...`));
+    await createStudioViteConfig(buildPath);
 
     // Run Vite build process
     console.log(chalk.gray(`   Running Vite build process...`));
@@ -1036,9 +1070,9 @@ async function buildStudioUIWithCustomQuestions(
     const studioPackageJsonPath = path.join(buildPath, 'package.json');
     await transformPackageJsonForStudioBuild(studioPackageJsonPath);
 
-    // Step 2.5: Fix Vite config to use npm packages instead of monorepo paths
-    console.log(chalk.gray(`   Updating Vite configuration for standalone build...`));
-    await fixViteConfigForStandaloneBuild(buildPath);
+    // Step 2.5: Fix Vite config to use npm packages and resolve custom questions imports
+    console.log(chalk.gray(`   Updating Vite configuration for studio build...`));
+    await createStudioViteConfig(buildPath);
 
     // Step 3: Install custom questions package
     console.log(
@@ -1259,9 +1293,9 @@ async function runViteBuild(buildPath: string): Promise<void> {
 }
 
 /**
- * Fix Vite configuration to work in standalone build environment
+ * Create Vite configuration for studio-ui build environment
  */
-async function fixViteConfigForStandaloneBuild(buildPath: string): Promise<void> {
+async function createStudioViteConfig(buildPath: string): Promise<void> {
   const viteConfigPath = path.join(buildPath, 'vite.config.ts');
 
   if (!fs.existsSync(viteConfigPath)) {
@@ -1269,9 +1303,9 @@ async function fixViteConfigForStandaloneBuild(buildPath: string): Promise<void>
     return;
   }
 
-  // Create a clean standalone vite config for external projects
-  // Relies on standard npm package resolution instead of monorepo paths
-  const standaloneViteConfig = `import { defineConfig } from 'vite';
+  // Create a clean studio vite config for studio-ui environment
+  // Includes aliases to resolve custom questions imports
+  const studioViteConfig = `import { defineConfig } from 'vite';
 import vue from '@vitejs/plugin-vue';
 
 export default defineConfig({
@@ -1297,9 +1331,17 @@ export default defineConfig({
   },
   resolve: {
     extensions: ['.js', '.ts', '.json', '.vue'],
+    alias: {
+      // Resolve @vue-skuilder packages to npm packages for custom questions import
+      '@vue-skuilder/common': '@vue-skuilder/common',
+      '@vue-skuilder/courseware': '@vue-skuilder/courseware',
+      '@vue-skuilder/db': '@vue-skuilder/db',
+      '@vue-skuilder/common-ui': '@vue-skuilder/common-ui',
+      '@vue-skuilder/edit-ui': '@vue-skuilder/edit-ui'
+    },
     dedupe: [
       'vue',
-      'vuetify', 
+      'vuetify',
       'vue-router',
       'pinia',
       '@vue-skuilder/db',
@@ -1311,50 +1353,23 @@ export default defineConfig({
   }
 });`;
 
-  fs.writeFileSync(viteConfigPath, standaloneViteConfig);
-  console.log(chalk.gray(`   Vite config replaced with standalone version`));
+  fs.writeFileSync(viteConfigPath, studioViteConfig);
+  console.log(chalk.gray(`   Vite config replaced with studio version`));
 }
 
 /**
- * Determine the correct MCP server executable path/command based on project context
+ * Determine the correct MCP server executable path.
+ * This is now greatly simplified because the bundled server is always
+ * located relative to this `studio.ts` file.
  */
-function resolveMCPExecutable(projectPath: string): {
-  command: string;
-  args: string[];
-  isNpx: boolean;
-} {
-  // Check if we're in the monorepo (packages/cli exists)
-  const monorepoCliPath = path.join(projectPath, 'packages', 'cli', 'dist', 'mcp-server.js');
-  if (fs.existsSync(monorepoCliPath)) {
-    return {
-      command: './packages/cli/dist/mcp-server.js',
-      args: [],
-      isNpx: false,
-    };
-  }
-
-  // Check if @vue-skuilder/cli is installed as a dependency
-  const scaffoldedCliPath = path.join(
-    projectPath,
-    'node_modules',
-    '@vue-skuilder',
-    'cli',
-    'dist',
-    'mcp-server.js'
-  );
-  if (fs.existsSync(scaffoldedCliPath)) {
-    return {
-      command: './node_modules/@vue-skuilder/cli/dist/mcp-server.js',
-      args: [],
-      isNpx: false,
-    };
-  }
+function resolveMCPExecutable(): { command: string; args: string[] } {
+  // Resolve the path to the bundled server relative to the current file.
+  // __dirname is the `dist/commands` directory.
+  const serverPath = path.resolve(__dirname, '..', 'mcp-server.js');
 
-  // Fallback to npx approach
   return {
-    command: 'npx',
-    args: ['@vue-skuilder/cli', 'mcp-server'],
-    isNpx: true,
+    command: 'node',
+    args: [serverPath],
   };
 }
 
@@ -1363,19 +1378,16 @@ function resolveMCPExecutable(projectPath: string): {
  */
 function getMCPConnectionInfo(
   unpackResult: UnpackResult,
-  couchDBManager: CouchDBManager,
-  projectPath: string
+  couchDBManager: CouchDBManager
 ): { command: string; env: Record<string, string> } {
   const couchDetails = couchDBManager.getConnectionDetails();
-  const executable = resolveMCPExecutable(projectPath);
+  const executable = resolveMCPExecutable();
+  const port = couchDetails.port || 5985;
 
   // Build command string for display
-  let commandStr: string;
-  if (executable.isNpx) {
-    commandStr = `${executable.command} ${executable.args.join(' ')} ${unpackResult.databaseName} ${couchDetails.port}`;
-  } else {
-    commandStr = `node ${executable.command} ${unpackResult.databaseName} ${couchDetails.port}`;
-  }
+  const commandStr = `${executable.command} ${executable.args.join(' ')} ${
+    unpackResult.databaseName
+  } ${port}`;
 
   return {
     command: commandStr,
@@ -1394,12 +1406,11 @@ function getMCPConnectionInfo(
 function generateMCPJson(
   unpackResult: UnpackResult,
   couchDBManager: CouchDBManager,
-  projectPath: string,
   serverName: string = 'vue-skuilder-studio'
 ): string {
   const couchDetails = couchDBManager.getConnectionDetails();
   const port = couchDetails.port || 5985;
-  const executable = resolveMCPExecutable(projectPath);
+  const executable = resolveMCPExecutable();
 
   const mcpConfig = {
     mcpServers: {
@@ -1418,3 +1429,69 @@ function generateMCPJson(
 
   return JSON.stringify(mcpConfig, null, 2);
 }
+
+/**
+ * Handle SUI course build process - extract questions hashing and UI building logic
+ */
+async function handleSuiCourse(coursePath: string): Promise<string> {
+  console.log(chalk.cyan(`🔍 Analyzing local question types...`));
+
+  try {
+    const questionsHash = await withStudioBuildErrorHandling(
+      () => hashQuestionsDirectory(coursePath),
+      StudioBuildErrorType.QUESTIONS_HASH_ERROR,
+      { coursePath: coursePath }
+    );
+
+    // Ensure cache directory exists
+    await ensureCacheDirectory(coursePath);
+
+    const buildExists = studioBuildExists(coursePath, questionsHash);
+    const buildPath = getStudioBuildPath(coursePath, questionsHash);
+
+    console.log(chalk.gray(`   Questions hash: ${questionsHash}`));
+    console.log(chalk.gray(`   Cached build exists: ${buildExists ? 'Yes' : 'No'}`));
+
+    let studioUIPath: string;
+
+    // Determine if we need to rebuild studio-ui
+    if (buildExists) {
+      console.log(chalk.gray(`   Using cached build at: ${buildPath}`));
+      studioUIPath = buildPath;
+    } else {
+      console.log(chalk.cyan(`🔨 Building studio-ui with local question types...`));
+      studioUIPath = await buildStudioUIWithQuestions(coursePath, questionsHash);
+      console.log(chalk.green(`✅ Studio-UI build complete: ${studioUIPath}`));
+    }
+
+    return studioUIPath;
+  } catch (error) {
+    // Handle catastrophic build errors by falling back to embedded source
+    console.log(
+      chalk.yellow(`⚠️  Unable to process questions due to ${error},\n⚠️  Using embedded studio-ui`)
+    );
+
+    const embeddedPath = path.join(__dirname, '..', 'studio-ui-src');
+
+    if (fs.existsSync(embeddedPath)) {
+      const studioUIPath = embeddedPath;
+      console.log(chalk.gray(`   Using embedded studio-ui source directly`));
+      return studioUIPath;
+    } else {
+      console.error(chalk.red(`❌ No viable studio-ui source available`));
+      throw new Error('Critical error: Cannot locate studio-ui source');
+    }
+  }
+}
+
+/**
+ * Handle manifest course - simple default build without custom questions
+ */
+async function handleManifestCourse(): Promise<string> {
+  console.log(chalk.cyan(`📋 Manifest mode: using default studio-ui build`));
+
+  const manifestBuildPath = path.join(__dirname, '..', 'studio-builds', 'manifest-default');
+  const studioUIPath = await buildDefaultStudioUI(manifestBuildPath);
+
+  return studioUIPath;
+}

package/src/mcp-server.ts

@@ -1,7 +1,9 @@
-#!/usr/bin/env node
+// MCP Server for Vue-Skuilder courses
+// This file is bundled into a self-contained executable
 
 import { initializeDataLayer, getDataLayer, initializeTuiLogging } from '@vue-skuilder/db';
 import { MCPServer } from '@vue-skuilder/mcp';
+import { consoleLogger } from '@vue-skuilder/common';
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
 
 initializeTuiLogging();
@@ -42,10 +44,11 @@ async function main() {
     await initializeDataLayer(couchdbConfig);
     const courseDB = getDataLayer().getCourseDB(courseId);
 
-    // Create and start MCP server
+    // Create and start MCP server with console logger
     const server = new MCPServer(courseDB, {
       enableSourceLinking: true,
       maxCardsPerQuery: 50,
+      logger: consoleLogger,
     });
 
     const transport = new StdioServerTransport();
@@ -53,7 +56,9 @@ async function main() {
 
     console.error('MCP Server started successfully!');
     console.error(`Course: ${courseId}`);
-    console.error('Available resources: course://config, cards://all, tags://all, shapes://all');
+    console.error('Available resources: course://config, cards://all, cards://tag/{tagName}, cards://shape/{shapeName}, cards://elo/{eloRange}');
+    console.error('                     shapes://all, shapes://{shapeName}, schema://{dataShapeName}');
+    console.error('                     tags://all, tags://stats, tags://{tagName}, tags://union/{tags}, tags://intersect/{tags}, tags://exclusive/{tags}, tags://distribution');
     console.error('Available tools: create_card, update_card, tag_card, delete_card');
     console.error('Available prompts: fill-in-card-authoring, elo-scoring-guidance');
     console.error('Ready for MCP client connections via stdio');

package/src/utils/template.ts

@@ -200,27 +200,22 @@ export default defineConfig({
         },
         rollupOptions: {
           // External packages that shouldn't be bundled in library mode
+          // For studio integration, we bundle vue-skuilder packages to avoid npm resolution issues
           external: [
-            'vue',
-            'vue-router',
-            'vuetify',
-            'pinia',
-            '@vue-skuilder/common',
-            '@vue-skuilder/common-ui',
-            '@vue-skuilder/courseware',
-            '@vue-skuilder/db',
+            // Bundle everything for studio integration - no externals
           ],
           output: {
             // Global variables for UMD build
             globals: {
-              'vue': 'Vue',
+              vue: 'Vue',
               'vue-router': 'VueRouter',
-              'vuetify': 'Vuetify',
-              'pinia': 'Pinia',
-              '@vue-skuilder/common': 'VueSkuilderCommon',
-              '@vue-skuilder/common-ui': 'VueSkuilderCommonUI',
-              '@vue-skuilder/courseware': 'VueSkuilderCourseWare',
-              '@vue-skuilder/db': 'VueSkuilderDB',
+              vuetify: 'Vuetify',
+              pinia: 'Pinia',
+              // Remove globals for bundled packages
+              // '@vue-skuilder/common': 'VueSkuilderCommon',
+              // '@vue-skuilder/common-ui': 'VueSkuilderCommonUI',
+              // '@vue-skuilder/courseware': 'VueSkuilderCourseWare',
+              // '@vue-skuilder/db': 'VueSkuilderDB',
             },
             exports: 'named',
             // Preserve CSS in the output bundle
@@ -421,6 +416,7 @@ node_modules/
 # Production builds
 /dist
 /build
+/dist-lib
 
 # Local env files
 .env