@vue-skuilder/cli 0.1.11-9 → 0.1.12

package/CLAUDE.md

@@ -16,9 +16,11 @@ npx @vue-skuilder/cli pack my-course
 ```
 
 ## Build System
-- **TypeScript**: Direct compilation to CommonJS in `dist/`
+- **TypeScript**: Direct compilation to ES module in `dist/`
 - **Binary Entry**: `dist/cli.js` with executable shebang
 - **Module Type**: ES module with `.js` extension
+- **Asset Embedding**: Templates and UI source files embedded during build
+- **Complex Build**: Multi-step process with template copying and path adjustments
 
 ## CLI Commands
 
@@ -35,8 +37,14 @@ npx @vue-skuilder/cli pack my-course
 - `inquirer` - Interactive prompts and wizards
 - `chalk` - Terminal color output
 
-### Vue-Skuilder Integration
+### Vue-Skuilder Integration (All Workspace Packages)
+- `@vue-skuilder/common` - Shared types and utilities
+- `@vue-skuilder/common-ui` - Base UI components
+- `@vue-skuilder/courseware` - Course content types and question implementations
 - `@vue-skuilder/db` - Database utilities for course packaging
+- `@vue-skuilder/edit-ui` - Course editing interface components
+- `@vue-skuilder/express` - Express server for API endpoints
+- `@vue-skuilder/mcp` - Model Context Protocol server integration
 - `@vue-skuilder/standalone-ui` - Standalone player for packaged courses
 
 ### File Management
@@ -63,11 +71,12 @@ npx @vue-skuilder/cli pack my-course
 - **Optimization**: Minifies and optimizes course assets
 - **Packaging**: Creates deployable course bundle
 
-### MCP Server (`mcp-server.ts`)
-- **Protocol Implementation**: Full MCP server with 14 resources, 4 tools, 2 prompts
+### MCP Server Integration
+- **Protocol Implementation**: Leverages `@vue-skuilder/mcp` package for full server functionality
 - **Course Access**: Direct CourseDBInterface integration for real-time data
-- **Content Generation**: AI-powered card creation and content authoring
+- **Content Generation**: AI-powered card creation and content authoring via Claude Code
 - **ELO Integration**: Native support for difficulty rating system
+- **Studio Command**: Launches MCP server alongside development environment
 
 ## Utilities
 

package/README.md

@@ -73,10 +73,11 @@ skuilder init biology-course \
 Studio mode provides a complete visual editing environment for static courses:
 
 ```bash
-skuilder studio                    # Launch in current directory
-skuilder studio ./my-course        # Launch against specific packed course directory
-skuilder studio --port 6000        # Use custom CouchDB port
-skuilder studio --no-browser       # Don't auto-open browser
+skuilder studio                       # Launch in current directory
+skuilder studio ./my-course           # Launch against specific skuilder app w/ packed course data
+skuilder studio ./some/manifest.json  # Launch against a specific packed course on disk
+skuilder studio --port 6000           # Use custom CouchDB port
+skuilder studio --no-browser          # Don't auto-open browser
 ```
 
 #### What Studio Mode Does

package/dist/commands/studio.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"studio.d.ts","sourceRoot":"","sources":["../../src/commands/studio.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAoDpC,wBAAgB,mBAAmB,IAAI,OAAO,CAoC7C"}
+{"version":3,"file":"studio.d.ts","sourceRoot":"","sources":["../../src/commands/studio.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAoDpC,wBAAgB,mBAAmB,IAAI,OAAO,CAuC7C"}

package/dist/commands/studio.js

@@ -39,7 +39,7 @@ async function findAvailablePort(startPort) {
 export function createStudioCommand() {
     return new Command('studio')
         .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)
@@ -59,8 +59,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
@@ -75,74 +78,54 @@ let studioUIServer = null;
 async function launchStudio(coursePath, options) {
     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.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}`));
         }
-        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;
-        let studioUIPath;
-        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');
+        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());
-        // Phase 9.5: Launch Express backend
-        console.log(chalk.cyan(`⚡ Starting Express backend server...`));
-        const expressResult = await startExpressBackend(couchDBManager.getConnectionDetails(), resolvedPath, unpackResult.databaseName);
+        const unpackResult = await unpackCourseToStudio(actualCoursePath, couchDBManager.getConnectionDetails(), isManifestMode);
+        // Start Express API server
+        const expressResult = await startExpressBackend(couchDBManager.getConnectionDetails(), 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(`   Debug: Unpack result - Database: "${unpackResult.databaseName}", Course ID: "${unpackResult.courseId}"`));
-        const studioUIPort = await startStudioUIServer(couchDBManager.getConnectionDetails(), unpackResult, studioUIPath);
+        const studioUIPort = await startStudioUIServer(couchDBManager.getConnectionDetails(), unpackResult, studioUIPath, expressResult.url);
         console.log(chalk.green(`✅ Studio session ready!`));
         console.log(chalk.white(`🎨 Studio URL: http://localhost:${studioUIPort}`));
         console.log(chalk.gray(`   Database: ${studioDatabaseName} on port ${options.port}`));
         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:`));
@@ -150,7 +133,7 @@ async function launchStudio(coursePath, options) {
             console.log(chalk.gray(`     ${key}=${value}`));
         });
         // 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));
         if (options.browser) {
@@ -158,7 +141,7 @@ async function launchStudio(coursePath, options) {
             await openBrowser(`http://localhost:${studioUIPort}`);
         }
         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...`));
@@ -183,7 +166,41 @@ async function launchStudio(coursePath, options) {
     }
 }
 /**
- * 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) {
+    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) {
     try {
@@ -300,7 +317,7 @@ async function stopStudioSession() {
         couchDBManager = null;
     }
 }
-async function startStudioUIServer(connectionDetails, unpackResult, studioPath) {
+async function startStudioUIServer(connectionDetails, unpackResult, studioPath, expressApiUrl) {
     // Serve from built dist directory if it exists, otherwise fallback to source
     const distPath = path.join(studioPath, 'dist');
     const studioSourcePath = fs.existsSync(distPath) ? distPath : studioPath;
@@ -348,6 +365,9 @@ async function startStudioUIServer(connectionDetails, unpackResult, studioPath)
                     name: '${unpackResult.databaseName}',
                     courseId: '${unpackResult.courseId}',
                     originalCourseId: '${unpackResult.courseId}'
+                  },
+                  express: {
+                    url: '${expressApiUrl || 'http://localhost:3000'}'
                   }
                 };
               </script>
@@ -375,6 +395,9 @@ async function startStudioUIServer(connectionDetails, unpackResult, studioPath)
                     name: '${unpackResult.databaseName}',
                     courseId: '${unpackResult.courseId}',
                     originalCourseId: '${unpackResult.courseId}'
+                  },
+                  express: {
+                    url: '${expressApiUrl || 'http://localhost:3000'}'
                   }
                 };
               </script>
@@ -444,7 +467,7 @@ async function openBrowser(url) {
 /**
  * Phase 9.5: Start Express backend server
  */
-async function startExpressBackend(couchDbConnectionDetails, _projectPath, databaseName) {
+async function startExpressBackend(couchDbConnectionDetails, databaseName) {
     console.log(chalk.blue('⚡ Starting Express backend server...'));
     // Find available port starting from 3001
     const availablePort = await findAvailablePort(3001);
@@ -470,6 +493,8 @@ async function startExpressBackend(couchDbConnectionDetails, _projectPath, datab
         },
     };
     try {
+        // Set NODE_ENV for studio mode authentication bypass
+        process.env.NODE_ENV = 'studio';
         // Create Express app using factory
         const app = createExpressApp(config);
         // Start server
@@ -495,29 +520,37 @@ async function startExpressBackend(couchDbConnectionDetails, _projectPath, datab
 /**
  * Phase 4: Unpack course data to studio CouchDB
  */
-async function unpackCourseToStudio(coursePath, connectionDetails) {
+async function unpackCourseToStudio(coursePath, connectionDetails, isManifestMode = false) {
     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;
+        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/');
-            }
         }
         console.log(chalk.gray(`   Course data path: ${courseDataPath}`));
         console.log(chalk.gray(`   Running unpack directly...`));
@@ -648,9 +681,9 @@ async function buildDefaultStudioUI(buildPath) {
         console.log(chalk.gray(`   Transforming workspace dependencies...`));
         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...`));
         await runViteBuild(buildPath);
@@ -788,9 +821,9 @@ async function buildStudioUIWithCustomQuestions(buildPath, customQuestionsData)
         console.log(chalk.gray(`   Transforming workspace dependencies...`));
         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(chalk.cyan(`   Installing bundled course package: ${customQuestionsData.packageName} from ${customQuestionsData.coursePath}`));
         const distLibPath = path.join(customQuestionsData.coursePath, 'dist-lib');
@@ -954,17 +987,17 @@ async function runViteBuild(buildPath) {
     });
 }
 /**
- * Fix Vite configuration to work in standalone build environment
+ * Create Vite configuration for studio-ui build environment
  */
-async function fixViteConfigForStandaloneBuild(buildPath) {
+async function createStudioViteConfig(buildPath) {
     const viteConfigPath = path.join(buildPath, 'vite.config.ts');
     if (!fs.existsSync(viteConfigPath)) {
         console.log(chalk.yellow(`   Warning: vite.config.ts not found at ${viteConfigPath}`));
         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({
@@ -990,9 +1023,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',
@@ -1003,52 +1044,32 @@ 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) {
-    // 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,
-        };
-    }
-    // Fallback to npx approach
+function resolveMCPExecutable() {
+    // 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');
     return {
-        command: 'npx',
-        args: ['@vue-skuilder/cli', 'mcp-server'],
-        isNpx: true,
+        command: 'node',
+        args: [serverPath],
     };
 }
 /**
  * Generate MCP connection information for studio session
  */
-function getMCPConnectionInfo(unpackResult, couchDBManager, projectPath) {
+function getMCPConnectionInfo(unpackResult, couchDBManager) {
     const couchDetails = couchDBManager.getConnectionDetails();
-    const executable = resolveMCPExecutable(projectPath);
+    const executable = resolveMCPExecutable();
+    const port = couchDetails.port || 5985;
     // Build command string for display
-    let commandStr;
-    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,
         env: {
@@ -1062,10 +1083,10 @@ function getMCPConnectionInfo(unpackResult, couchDBManager, projectPath) {
 /**
  * Generate .mcp.json content for Claude Code integration
  */
-function generateMCPJson(unpackResult, couchDBManager, projectPath, serverName = 'vue-skuilder-studio') {
+function generateMCPJson(unpackResult, couchDBManager, serverName = 'vue-skuilder-studio') {
     const couchDetails = couchDBManager.getConnectionDetails();
     const port = couchDetails.port || 5985;
-    const executable = resolveMCPExecutable(projectPath);
+    const executable = resolveMCPExecutable();
     const mcpConfig = {
         mcpServers: {
             [serverName]: {
@@ -1082,4 +1103,54 @@ function generateMCPJson(unpackResult, couchDBManager, projectPath, serverName =
     };
     return JSON.stringify(mcpConfig, null, 2);
 }
+/**
+ * Handle SUI course build process - extract questions hashing and UI building logic
+ */
+async function handleSuiCourse(coursePath) {
+    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;
+        // 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() {
+    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;
+}
 //# sourceMappingURL=studio.js.map