@launchframe/cli 0.1.11 → 1.0.0-beta.2

package/src/utils/module-cache.js

@@ -0,0 +1,274 @@
+const path = require('path');
+const fs = require('fs-extra');
+const os = require('os');
+const { execSync } = require('child_process');
+const chalk = require('chalk');
+
+const MODULES_REPO = 'git@github.com:launchframe-dev/modules.git';
+const BRANCH = 'main';
+
+/**
+ * Get the cache directory path
+ * Works cross-platform (Linux, Mac, Windows)
+ * @returns {string} Cache directory path
+ */
+function getCacheDir() {
+  const homeDir = os.homedir();
+  // Use same path structure on all platforms
+  // Windows: C:\Users\username\.launchframe\cache\modules
+  // Mac/Linux: /home/username/.launchframe/cache/modules
+  return path.join(homeDir, '.launchframe', 'cache', 'modules');
+}
+
+/**
+ * Check if cache exists and is valid
+ * @returns {boolean} True if cache exists
+ */
+async function cacheExists() {
+  const cacheDir = getCacheDir();
+  const gitDir = path.join(cacheDir, '.git');
+  return await fs.pathExists(gitDir);
+}
+
+/**
+ * Initialize cache with sparse checkout
+ * Clones only the repository structure, no modules yet
+ * @returns {Promise<void>}
+ */
+async function initializeCache() {
+  const cacheDir = getCacheDir();
+  
+  console.log(chalk.blue('🔄 Initializing module cache...'));
+  
+  try {
+    // Ensure parent directory exists
+    await fs.ensureDir(path.dirname(cacheDir));
+    
+    // Sparse clone (only root files, no modules)
+    execSync(
+      `git clone --sparse --depth 1 --branch ${BRANCH} ${MODULES_REPO} "${cacheDir}"`,
+      { 
+        stdio: 'pipe', // Hide output
+        timeout: 60000 // 1 minute timeout
+      }
+    );
+    
+    // Configure sparse checkout (starts with empty set)
+    execSync('git sparse-checkout init --cone', {
+      cwd: cacheDir,
+      stdio: 'pipe'
+    });
+    
+    console.log(chalk.green('✓ Cache initialized'));
+  } catch (error) {
+    // Clean up partial clone on failure
+    await fs.remove(cacheDir);
+    throw new Error(`Failed to initialize cache: ${error.message}`);
+  }
+}
+
+/**
+ * Update cache to latest version from main branch
+ * Requires internet connection
+ * @returns {Promise<void>}
+ */
+async function updateCache() {
+  const cacheDir = getCacheDir();
+  
+  console.log(chalk.blue('🔄 Updating module cache...'));
+  
+  try {
+    execSync('git pull origin main', {
+      cwd: cacheDir,
+      stdio: 'pipe',
+      timeout: 30000 // 30 seconds
+    });
+    
+    console.log(chalk.green('✓ Cache updated'));
+  } catch (error) {
+    throw new Error(`Failed to update cache: ${error.message}`);
+  }
+}
+
+/**
+ * Expand sparse checkout to include specific modules
+ * @param {string[]} moduleNames - Array of module names to expand
+ * @returns {Promise<void>}
+ */
+async function expandModules(moduleNames) {
+  const cacheDir = getCacheDir();
+  
+  console.log(chalk.blue(`📦 Loading modules: ${moduleNames.join(', ')}...`));
+  
+  try {
+    // Get current sparse checkout list
+    let currentModules = [];
+    try {
+      const output = execSync('git sparse-checkout list', {
+        cwd: cacheDir,
+        stdio: 'pipe',
+        encoding: 'utf8'
+      });
+      currentModules = output.trim().split('\n').filter(Boolean);
+    } catch (error) {
+      // No modules yet, that's fine
+    }
+    
+    // Add new modules to the list
+    const allModules = [...new Set([...currentModules, ...moduleNames])];
+    
+    // Set sparse checkout to include all modules
+    execSync(`git sparse-checkout set ${allModules.join(' ')}`, {
+      cwd: cacheDir,
+      stdio: 'pipe',
+      timeout: 60000 // 1 minute (may need to download files)
+    });
+    
+    console.log(chalk.green('✓ Modules loaded'));
+  } catch (error) {
+    throw new Error(`Failed to expand modules: ${error.message}`);
+  }
+}
+
+/**
+ * Get path to a specific module in the cache
+ * @param {string} moduleName - Module name (e.g., 'backend', 'admin-portal')
+ * @returns {string} Absolute path to module
+ */
+function getModulePath(moduleName) {
+  const cacheDir = getCacheDir();
+  return path.join(cacheDir, moduleName);
+}
+
+/**
+ * Get cache root path
+ * @returns {string} Absolute path to cache root
+ */
+function getCachePath() {
+  return getCacheDir();
+}
+
+/**
+ * Clear the entire module cache
+ * Useful for troubleshooting or forcing fresh download
+ * @returns {Promise<void>}
+ */
+async function clearCache() {
+  const cacheDir = getCacheDir();
+  
+  if (await fs.pathExists(cacheDir)) {
+    await fs.remove(cacheDir);
+    console.log(chalk.green('✓ Cache cleared'));
+  } else {
+    console.log(chalk.gray('Cache is already empty'));
+  }
+}
+
+/**
+ * Get cache information (size, last update, modules)
+ * @returns {Promise<{exists: boolean, path: string, size?: number, modules?: string[], lastUpdate?: Date}>}
+ */
+async function getCacheInfo() {
+  const cacheDir = getCacheDir();
+  const info = {
+    exists: false,
+    path: cacheDir
+  };
+  
+  if (!(await cacheExists())) {
+    return info;
+  }
+  
+  info.exists = true;
+  
+  try {
+    // Get cache size (du command works on Unix/Mac, different on Windows)
+    if (process.platform === 'win32') {
+      // Windows: use powershell to get size
+      const output = execSync(
+        `powershell -command "(Get-ChildItem -Path '${cacheDir}' -Recurse | Measure-Object -Property Length -Sum).Sum"`,
+        { encoding: 'utf8', stdio: 'pipe' }
+      );
+      info.size = parseInt(output.trim());
+    } else {
+      // Unix/Mac: use du
+      const output = execSync(`du -sb "${cacheDir}"`, {
+        encoding: 'utf8',
+        stdio: 'pipe'
+      });
+      info.size = parseInt(output.split('\t')[0]);
+    }
+  } catch (error) {
+    // Size calculation failed, not critical
+  }
+  
+  try {
+    // Get list of expanded modules
+    const output = execSync('git sparse-checkout list', {
+      cwd: cacheDir,
+      encoding: 'utf8',
+      stdio: 'pipe'
+    });
+    info.modules = output.trim().split('\n').filter(Boolean);
+  } catch (error) {
+    info.modules = [];
+  }
+  
+  try {
+    // Get last update time from git log
+    const output = execSync('git log -1 --format=%cd --date=iso', {
+      cwd: cacheDir,
+      encoding: 'utf8',
+      stdio: 'pipe'
+    });
+    info.lastUpdate = new Date(output.trim());
+  } catch (error) {
+    // Last update time failed, not critical
+  }
+  
+  return info;
+}
+
+/**
+ * Ensure cache is ready (initialize if needed, update if exists)
+ * This is the main entry point for cache management
+ * @param {string[]} requiredModules - Modules needed for the operation
+ * @returns {Promise<string>} Path to cache root
+ */
+async function ensureCacheReady(requiredModules) {
+  try {
+    if (!(await cacheExists())) {
+      // Cache doesn't exist, initialize it
+      await initializeCache();
+    } else {
+      // Cache exists, update it
+      await updateCache();
+    }
+    
+    // Expand sparse checkout to include required modules
+    await expandModules(requiredModules);
+    
+    return getCachePath();
+  } catch (error) {
+    // If we fail and it's a network error, provide helpful message
+    if (error.message.includes('Connection') || error.message.includes('timed out')) {
+      throw new Error(
+        'Cannot connect to GitHub. Please check your internet connection and try again.'
+      );
+    }
+    throw error;
+  }
+}
+
+module.exports = {
+  getCacheDir,
+  cacheExists,
+  initializeCache,
+  updateCache,
+  expandModules,
+  getModulePath,
+  getCachePath,
+  clearCache,
+  getCacheInfo,
+  ensureCacheReady
+};

package/src/utils/project-helpers.js

@@ -76,7 +76,7 @@ function addInstalledComponent(componentName) {
  * @returns {string|null} Primary domain
  */
 function getPrimaryDomain(config) {
-  return config.primaryDomain || null;
+  return config.deployment?.primaryDomain || null;
 }
 
 /**

package/src/utils/section-replacer.js

@@ -9,32 +9,46 @@ const fs = require('fs-extra');
 async function replaceSection(filePath, sectionName, newContent) {
   const content = await fs.readFile(filePath, 'utf8');
 
-  // Try both comment formats (// for regular comments, {/* */} for JSX)
-  const startMarkerRegular = `// ${sectionName}_START`;
-  const endMarkerRegular = `// ${sectionName}_END`;
+  // Try all comment formats (// for JS/TS, {/* */} for JSX, # for YAML/Shell)
+  const startMarkerSlash = `// ${sectionName}_START`;
+  const endMarkerSlash = `// ${sectionName}_END`;
   const startMarkerJSX = `{/* ${sectionName}_START */}`;
   const endMarkerJSX = `{/* ${sectionName}_END */}`;
+  const startMarkerHash = `# ${sectionName}_START`;
+  const endMarkerHash = `# ${sectionName}_END`;
 
-  let startIndex = content.indexOf(startMarkerRegular);
-  let endIndex = content.indexOf(endMarkerRegular);
-  let isJSX = false;
+  let startIndex = content.indexOf(startMarkerSlash);
+  let endIndex = content.indexOf(endMarkerSlash);
 
-  // If not found with regular comments, try JSX comments
+  // If not found with // comments, try JSX comments
   if (startIndex === -1 || endIndex === -1) {
     startIndex = content.indexOf(startMarkerJSX);
     endIndex = content.indexOf(endMarkerJSX);
-    isJSX = true;
+  }
+
+  // If not found with JSX comments, try # comments (YAML/Shell)
+  if (startIndex === -1 || endIndex === -1) {
+    startIndex = content.indexOf(startMarkerHash);
+    endIndex = content.indexOf(endMarkerHash);
   }
 
   if (startIndex === -1 || endIndex === -1) {
     throw new Error(`Section markers not found: ${sectionName} in ${filePath}`);
   }
 
+  // Find the start of the start marker line (beginning of line, not just the marker)
+  let lineStart = content.lastIndexOf('\n', startIndex - 1);
+  if (lineStart === -1) {
+    lineStart = 0; // Marker is on first line
+  } else {
+    lineStart += 1; // Move past the newline to the start of the line
+  }
+
   // Find the end of the end marker line
   const endLineEnd = content.indexOf('\n', endIndex);
 
-  // Construct new content - exclude both marker lines
-  const before = content.substring(0, startIndex);
+  // Construct new content - exclude both marker lines (including leading whitespace)
+  const before = content.substring(0, lineStart);
   const after = content.substring(endLineEnd + 1);
   const replaced = before + newContent + after;
 
@@ -50,16 +64,19 @@ async function replaceSection(filePath, sectionName, newContent) {
 async function hasSection(filePath, sectionName) {
   try {
     const content = await fs.readFile(filePath, 'utf8');
-    const startMarkerRegular = `// ${sectionName}_START`;
-    const endMarkerRegular = `// ${sectionName}_END`;
+    const startMarkerSlash = `// ${sectionName}_START`;
+    const endMarkerSlash = `// ${sectionName}_END`;
     const startMarkerJSX = `{/* ${sectionName}_START */}`;
     const endMarkerJSX = `{/* ${sectionName}_END */}`;
+    const startMarkerHash = `# ${sectionName}_START`;
+    const endMarkerHash = `# ${sectionName}_END`;
 
-    // Check both comment formats
-    const hasRegular = content.includes(startMarkerRegular) && content.includes(endMarkerRegular);
+    // Check all comment formats
+    const hasSlash = content.includes(startMarkerSlash) && content.includes(endMarkerSlash);
     const hasJSX = content.includes(startMarkerJSX) && content.includes(endMarkerJSX);
+    const hasHash = content.includes(startMarkerHash) && content.includes(endMarkerHash);
 
-    return hasRegular || hasJSX;
+    return hasSlash || hasJSX || hasHash;
   } catch (error) {
     return false;
   }

package/src/utils/variable-replacer.js

@@ -55,7 +55,10 @@ function escapeRegex(string) {
  */
 async function replaceVariablesInFile(filePath, variables) {
   try {
-    let content = await fs.readFile(filePath, 'utf8');
+    // Read file content - preserve line endings for shell scripts
+    // Use binary mode to avoid Node.js line ending normalization on Windows
+    const buffer = await fs.readFile(filePath);
+    let content = buffer.toString('utf8');
     let modified = false;
 
     // Replace each variable using regex with negative lookbehind
@@ -74,8 +77,10 @@ async function replaceVariablesInFile(filePath, variables) {
     }
 
     // Only write if changes were made
+    // Write as Buffer to preserve original line endings
     if (modified) {
-      await fs.writeFile(filePath, content, 'utf8');
+      const outputBuffer = Buffer.from(content, 'utf8');
+      await fs.writeFile(filePath, outputBuffer);
     }
 
     return modified;

package/src/utils/variant-processor.js

@@ -44,7 +44,7 @@ async function processServiceVariant(
   // Step 1: Copy base template (minimal - B2B + single-tenant)
   console.log(`  📁 Copying base template from ${serviceConfig.base}`);
   await copyDirectory(basePath, destination, {
-    exclude: ['node_modules', '.git', 'dist', '.env', 'templates']
+    exclude: ['node_modules', '.git', 'dist', '.env']
   });
 
   // Step 2: Determine which variants to apply
@@ -143,29 +143,41 @@ async function cleanupSectionMarkers(serviceName, serviceConfig, appliedVariants
       let content = await fs.readFile(targetFilePath, 'utf-8');
       let modified = false;
 
-      // Remove each unused section marker
+      // Remove each unused section marker (keep content, remove only marker comments)
       for (const sectionName of sectionNames) {
-        // Try both comment formats
-        const regularPattern = new RegExp(
-          `\\/\\/ ${sectionName}_START\\n[\\s\\S]*?\\/\\/ ${sectionName}_END\\n?`,
-          'g'
+        // Try all comment formats (// for JS/TS, {/* */} for JSX, # for YAML/Shell)
+        // Capture: START marker, content, END marker - replace with just content
+        // Include leading whitespace before markers to prevent indentation issues
+        const slashPattern = new RegExp(
+          `^[ \\t]*\\/\\/ ${sectionName}_START\\n([\\s\\S]*?)^[ \\t]*\\/\\/ ${sectionName}_END\\n?`,
+          'gm'
         );
         const jsxPattern = new RegExp(
-          `\\{\\/\\* ${sectionName}_START \\*\\/\\}\\n[\\s\\S]*?\\{\\/\\* ${sectionName}_END \\*\\/\\}\\n?`,
-          'g'
+          `^[ \\t]*\\{\\/\\* ${sectionName}_START \\*\\/\\}\\n([\\s\\S]*?)^[ \\t]*\\{\\/\\* ${sectionName}_END \\*\\/\\}\\n?`,
+          'gm'
+        );
+        const hashPattern = new RegExp(
+          `^[ \\t]*# ${sectionName}_START\\n([\\s\\S]*?)^[ \\t]*# ${sectionName}_END\\n?`,
+          'gm'
         );
 
-        const beforeRegular = content;
-        content = content.replace(regularPattern, '');
-        if (content !== beforeRegular) {
+        const beforeSlash = content;
+        content = content.replace(slashPattern, '$1');
+        if (content !== beforeSlash) {
           modified = true;
         }
 
         const beforeJsx = content;
-        content = content.replace(jsxPattern, '');
+        content = content.replace(jsxPattern, '$1');
         if (content !== beforeJsx) {
           modified = true;
         }
+
+        const beforeHash = content;
+        content = content.replace(hashPattern, '$1');
+        if (content !== beforeHash) {
+          modified = true;
+        }
       }
 
       if (modified) {