pulse-js-framework 1.7.31 → 1.7.33

package/cli/build.js

@@ -7,9 +7,13 @@
 import { readFileSync, writeFileSync, existsSync, mkdirSync, readdirSync, statSync, copyFileSync } from 'fs';
 import { join, extname, relative, dirname } from 'path';
 import { compile } from '../compiler/index.js';
+import { preprocessStylesSync, isSassAvailable, getSassVersion } from '../compiler/preprocessor.js';
 import { log } from './logger.js';
 import { createTimer, createProgressBar, formatDuration, createSpinner } from './utils/cli-ui.js';
 
+// SASS availability (checked once at build start)
+let sassAvailable = false;
+
 /**
  * Build project for production
  */
@@ -34,6 +38,13 @@ export async function buildProject(args) {
 
   log.info('Building with Pulse compiler...\n');
 
+  // Check for SASS availability
+  sassAvailable = isSassAvailable();
+  if (sassAvailable) {
+    const version = getSassVersion();
+    log.info(`  SASS support enabled (sass ${version || 'unknown'})`);
+  }
+
   // Create output directory
   if (!existsSync(outDir)) {
     mkdirSync(outDir, { recursive: true });
@@ -140,8 +151,30 @@ function processDirectory(srcDir, outDir, progress = null) {
       });
 
       if (result.success) {
+        let code = result.code;
+
+        // Preprocess SASS/SCSS in style blocks if sass is available
+        if (sassAvailable) {
+          const stylesMatch = code.match(/const styles = `([\s\S]*?)`;/);
+          if (stylesMatch) {
+            try {
+              const preprocessed = preprocessStylesSync(stylesMatch[1], {
+                filename: srcPath,
+                loadPaths: [dirname(srcPath)],
+                compressed: true
+              });
+
+              if (preprocessed.wasSass) {
+                code = code.replace(stylesMatch[0], `const styles = \`${preprocessed.css}\`;`);
+              }
+            } catch (sassError) {
+              log.warn(`  SASS warning in ${file}: ${sassError.message}`);
+            }
+          }
+        }
+
         const outPath = join(outDir, file.replace('.pulse', '.js'));
-        writeFileSync(outPath, result.code);
+        writeFileSync(outPath, code);
       } else {
         log.error(`  Error compiling ${file}:`);
         for (const error of result.errors) {

package/cli/dev.js

@@ -6,10 +6,14 @@
 
 import { createServer } from 'http';
 import { readFileSync, existsSync, statSync, watch } from 'fs';
-import { join, extname, resolve } from 'path';
+import { join, extname, resolve, dirname } from 'path';
 import { compile } from '../compiler/index.js';
+import { preprocessStylesSync, isSassAvailable, getSassVersion } from '../compiler/preprocessor.js';
 import { log } from './logger.js';
 
+// SASS availability (checked once at server start)
+let sassAvailable = false;
+
 const MIME_TYPES = {
   '.html': 'text/html',
   '.js': 'application/javascript',
@@ -87,6 +91,13 @@ export async function startDevServer(args) {
     // Vite not available, use built-in server
   }
 
+  // Check for SASS availability
+  sassAvailable = isSassAvailable();
+  if (sassAvailable) {
+    const version = getSassVersion();
+    log.info(`SASS support enabled (sass ${version || 'unknown'})`);
+  }
+
   // Built-in development server
   const server = createServer(async (req, res) => {
     const url = new URL(req.url, `http://localhost:${port}`);
@@ -128,11 +139,31 @@ export async function startDevServer(args) {
           });
 
           if (result.success) {
+            let code = result.code;
+
+            // Preprocess SASS/SCSS if available
+            if (sassAvailable) {
+              const stylesMatch = code.match(/const styles = `([\s\S]*?)`;/);
+              if (stylesMatch) {
+                try {
+                  const preprocessed = preprocessStylesSync(stylesMatch[1], {
+                    filename: filePath,
+                    loadPaths: [dirname(filePath)]
+                  });
+                  if (preprocessed.wasSass) {
+                    code = code.replace(stylesMatch[0], `const styles = \`${preprocessed.css}\`;`);
+                  }
+                } catch (sassError) {
+                  console.warn(`[Pulse] SASS warning: ${sassError.message}`);
+                }
+              }
+            }
+
             res.writeHead(200, {
               'Content-Type': 'application/javascript',
               'Cache-Control': 'no-cache, no-store, must-revalidate'
             });
-            res.end(result.code);
+            res.end(code);
           } else {
             const errorDetails = result.errors.map(e => `${e.message} at line ${e.line || '?'}:${e.column || '?'}`).join('\n');
             console.error(`[Pulse] Compilation error in ${filePath}:`, result.errors);
@@ -173,11 +204,31 @@ export async function startDevServer(args) {
           });
 
           if (result.success) {
+            let code = result.code;
+
+            // Preprocess SASS/SCSS if available
+            if (sassAvailable) {
+              const stylesMatch = code.match(/const styles = `([\s\S]*?)`;/);
+              if (stylesMatch) {
+                try {
+                  const preprocessed = preprocessStylesSync(stylesMatch[1], {
+                    filename: pulseFilePath,
+                    loadPaths: [dirname(pulseFilePath)]
+                  });
+                  if (preprocessed.wasSass) {
+                    code = code.replace(stylesMatch[0], `const styles = \`${preprocessed.css}\`;`);
+                  }
+                } catch (sassError) {
+                  console.warn(`[Pulse] SASS warning: ${sassError.message}`);
+                }
+              }
+            }
+
             res.writeHead(200, {
               'Content-Type': 'application/javascript',
               'Cache-Control': 'no-cache, no-store, must-revalidate'
             });
-            res.end(result.code);
+            res.end(code);
           } else {
             res.writeHead(500, { 'Content-Type': 'text/plain' });
             res.end(`Compilation error: ${result.errors.map(e => e.message).join('\n')}`);

package/cli/release.js

@@ -532,6 +532,92 @@ function verifyTagOnRemote(version) {
   }
 }
 
+/**
+ * Check if gh CLI is available
+ */
+function isGhCliAvailable() {
+  try {
+    execSync('gh --version', { cwd: root, stdio: 'ignore' });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Create GitHub release using gh CLI
+ */
+function createGitHubRelease(version, title, changes) {
+  if (!isGhCliAvailable()) {
+    log.warn('  gh CLI not available, skipping GitHub release creation');
+    log.info('  Install gh CLI: https://cli.github.com/');
+    return { success: false, reason: 'gh-not-installed' };
+  }
+
+  // Build release notes
+  let notes = '';
+
+  if (title) {
+    notes += `## ${title}\n\n`;
+  }
+
+  if (changes.added?.length > 0) {
+    notes += `### ✨ Added\n\n`;
+    for (const item of changes.added) {
+      notes += `- ${item}\n`;
+    }
+    notes += '\n';
+  }
+
+  if (changes.changed?.length > 0) {
+    notes += `### 🔄 Changed\n\n`;
+    for (const item of changes.changed) {
+      notes += `- ${item}\n`;
+    }
+    notes += '\n';
+  }
+
+  if (changes.fixed?.length > 0) {
+    notes += `### 🐛 Fixed\n\n`;
+    for (const item of changes.fixed) {
+      notes += `- ${item}\n`;
+    }
+    notes += '\n';
+  }
+
+  if (changes.removed?.length > 0) {
+    notes += `### 🗑️ Removed\n\n`;
+    for (const item of changes.removed) {
+      notes += `- ${item}\n`;
+    }
+    notes += '\n';
+  }
+
+  // Write notes to temp file
+  const tempFile = join(tmpdir(), `pulse-release-notes-${Date.now()}.md`);
+  writeFileSync(tempFile, notes, 'utf-8');
+
+  try {
+    const releaseTitle = title ? `v${version} - ${title}` : `v${version}`;
+    const command = `gh release create v${version} --title "${releaseTitle}" --notes-file "${tempFile}"`;
+
+    log.info(`  Creating GitHub release v${version}...`);
+    execSync(command, { cwd: root, stdio: 'inherit' });
+
+    log.info(`  GitHub release created successfully`);
+    return { success: true };
+  } catch (error) {
+    log.error(`  Failed to create GitHub release: ${error.message}`);
+    return { success: false, error };
+  } finally {
+    try {
+      unlinkSync(tempFile);
+    } catch {
+      // Ignore cleanup errors
+    }
+  }
+}
+
 /**
  * Execute a git command with error handling
  */
@@ -619,24 +705,53 @@ function gitCommitTagPush(newVersion, title, changes, dryRun = false) {
     return { success: false, stage: 'push', error: result.error };
   }
 
-  // git push --tags
-  result = execGitCommand('git push --tags', 'git push --tags');
-  if (!result.success) {
-    log.error('');
-    log.error('Tag push failed. The tag exists locally but not on remote.');
-    log.error('You can manually push tags with:');
-    log.error('  git push --tags');
-    return { success: false, stage: 'push-tags', error: result.error };
-  }
-
-  // Verify tag was pushed to remote
-  if (!verifyTagOnRemote(newVersion)) {
-    log.warn('');
-    log.warn('Tag push appeared to succeed but tag not found on remote.');
-    log.warn('You may need to manually verify or push with:');
-    log.warn('  git push --tags');
+  // git push --tags (use gh CLI if available for better error handling)
+  if (isGhCliAvailable()) {
+    // Use git push directly as gh doesn't have a push command
+    result = execGitCommand('git push --tags', 'git push --tags');
+    if (!result.success) {
+      log.error('');
+      log.error('Tag push failed. The tag exists locally but not on remote.');
+      log.error('You can manually push tags with:');
+      log.error('  git push --tags');
+      return { success: false, stage: 'push-tags', error: result.error };
+    }
+
+    // Verify tag was pushed using gh
+    try {
+      execSync(`gh release view v${newVersion}`, { cwd: root, stdio: 'ignore' });
+      log.info(`  Verified: tag v${newVersion} exists on remote (via gh)`);
+    } catch {
+      // Tag pushed but no release yet, which is fine
+      if (verifyTagOnRemote(newVersion)) {
+        log.info(`  Verified: tag v${newVersion} exists on remote`);
+      } else {
+        log.warn('');
+        log.warn('Tag push appeared to succeed but tag not found on remote.');
+        log.warn('You may need to manually verify or push with:');
+        log.warn('  git push --tags');
+      }
+    }
   } else {
-    log.info(`  Verified: tag v${newVersion} exists on remote`);
+    // Fallback to standard git push --tags
+    result = execGitCommand('git push --tags', 'git push --tags');
+    if (!result.success) {
+      log.error('');
+      log.error('Tag push failed. The tag exists locally but not on remote.');
+      log.error('You can manually push tags with:');
+      log.error('  git push --tags');
+      return { success: false, stage: 'push-tags', error: result.error };
+    }
+
+    // Verify tag was pushed to remote
+    if (!verifyTagOnRemote(newVersion)) {
+      log.warn('');
+      log.warn('Tag push appeared to succeed but tag not found on remote.');
+      log.warn('You may need to manually verify or push with:');
+      log.warn('  git push --tags');
+    } else {
+      log.info(`  Verified: tag v${newVersion} exists on remote`);
+    }
   }
 
   return { success: true };
@@ -714,6 +829,7 @@ Types:
 Options:
   --dry-run         Show what would be done without making changes
   --no-push         Create commit and tag but don't push
+  --no-gh-release   Skip creating GitHub release (only create tag)
   --title <text>    Release title (e.g., "Performance Improvements")
   --skip-prompt     Use empty changelog (for automated releases)
   --skip-docs-test  Skip documentation validation before release
@@ -733,6 +849,7 @@ Examples:
   pulse release patch --title "Security" --fixed "XSS vulnerability,SQL injection" -y
   pulse release patch --title "New API" --added "Feature A,Feature B" --fixed "Bug X" -y
   pulse release patch --discord-webhook "https://discord.com/api/webhooks/..."
+  pulse release patch --no-gh-release  # Create tag but skip GitHub release
   `);
 }
 
@@ -750,6 +867,7 @@ export async function runRelease(args) {
   // Parse options
   const dryRun = args.includes('--dry-run');
   const noPush = args.includes('--no-push');
+  const noGhRelease = args.includes('--no-gh-release');
   const skipPrompt = args.includes('--skip-prompt');
   const fromCommits = args.includes('--from-commits') || args.includes('--fc');
   const autoConfirm = args.includes('--yes') || args.includes('-y');
@@ -984,8 +1102,32 @@ export async function runRelease(args) {
   log.info(`Release v${newVersion} complete!`);
   log.info('');
 
+  // Create GitHub release using gh CLI
+  if (!dryRun && !noPush && !noGhRelease && hasChanges) {
+    log.info('Creating GitHub release...');
+    const ghResult = createGitHubRelease(newVersion, title, changes);
+
+    if (!ghResult.success) {
+      if (ghResult.reason === 'gh-not-installed') {
+        log.info('Manual step:');
+        log.info(`  Create GitHub release: https://github.com/vincenthirtz/pulse-js-framework/releases/new?tag=v${newVersion}`);
+      } else {
+        log.warn('GitHub release creation failed, but release was successful.');
+        log.info('Manual step:');
+        log.info(`  Create GitHub release: https://github.com/vincenthirtz/pulse-js-framework/releases/new?tag=v${newVersion}`);
+      }
+    }
+  } else if (dryRun) {
+    log.info('  [dry-run] Would create GitHub release using gh CLI');
+  } else if (noGhRelease) {
+    log.info('Skipping GitHub release creation (--no-gh-release)');
+    log.info('Manual step:');
+    log.info(`  Create GitHub release: https://github.com/vincenthirtz/pulse-js-framework/releases/new?tag=v${newVersion}`);
+  }
+
   // Send Discord notification if webhook URL provided
   if (discordWebhook && !dryRun) {
+    log.info('');
     log.info('Sending Discord notification...');
     try {
       await sendDiscordNotification(discordWebhook, newVersion, title, changes);
@@ -996,9 +1138,4 @@ export async function runRelease(args) {
   } else if (discordWebhook && dryRun) {
     log.info('  [dry-run] Would send Discord notification to webhook');
   }
-
-  if (!dryRun && !noPush) {
-    log.info('Next step:');
-    log.info(`  Create GitHub release: https://github.com/vincenthirtz/pulse-js-framework/releases/new?tag=v${newVersion}`);
-  }
 }

package/compiler/parser.js

@@ -1118,15 +1118,31 @@ export class Parser {
   }
 
   /**
-   * Parse assignment expression (a = b)
+   * Parse assignment expression (a = b, a += b, a -= b, etc.)
    */
   parseAssignmentExpression() {
     const left = this.parseConditionalExpression();
 
-    if (this.is(TokenType.EQ)) {
-      this.advance();
+    // Check for assignment operators
+    const assignmentOps = [
+      TokenType.EQ,           // =
+      TokenType.PLUS_ASSIGN,  // +=
+      TokenType.MINUS_ASSIGN, // -=
+      TokenType.STAR_ASSIGN,  // *=
+      TokenType.SLASH_ASSIGN, // /=
+      TokenType.AND_ASSIGN,   // &&=
+      TokenType.OR_ASSIGN,    // ||=
+      TokenType.NULLISH_ASSIGN // ??=
+    ];
+
+    if (this.isAny(...assignmentOps)) {
+      const operator = this.advance().value;
       const right = this.parseAssignmentExpression();
-      return new ASTNode(NodeType.AssignmentExpression, { left, right });
+      return new ASTNode(NodeType.AssignmentExpression, {
+        left,
+        right,
+        operator
+      });
     }
 
     return left;
@@ -1545,15 +1561,83 @@ export class Parser {
    */
   parseStyleBlock() {
     this.expect(TokenType.STYLE);
-    this.expect(TokenType.LBRACE);
+    const startBrace = this.expect(TokenType.LBRACE);
 
-    const rules = [];
-    while (!this.is(TokenType.RBRACE) && !this.is(TokenType.EOF)) {
-      rules.push(this.parseStyleRule());
+    // Extract raw CSS content for preprocessor support
+    // Instead of parsing token by token, collect all tokens until matching }
+    const rawTokens = [];
+    let braceDepth = 1; // We've already consumed the opening {
+    const startPos = this.pos;
+
+    while (braceDepth > 0 && !this.is(TokenType.EOF)) {
+      const token = this.current();
+      if (token.type === TokenType.LBRACE) braceDepth++;
+      if (token.type === TokenType.RBRACE) braceDepth--;
+
+      if (braceDepth > 0) {
+        rawTokens.push(token);
+        this.advance();
+      }
     }
 
     this.expect(TokenType.RBRACE);
-    return new ASTNode(NodeType.StyleBlock, { rules });
+
+    // Reconstruct raw CSS from tokens for preprocessor
+    const rawCSS = this.reconstructCSS(rawTokens);
+
+    // Try to parse as structured CSS (will work for plain CSS)
+    // If parsing fails, fall back to raw mode for preprocessors
+    let rules = [];
+    let parseError = null;
+
+    // Reset to try parsing
+    const savedPos = this.pos;
+    this.pos = startPos;
+
+    try {
+      while (!this.is(TokenType.RBRACE) && !this.is(TokenType.EOF)) {
+        rules.push(this.parseStyleRule());
+      }
+    } catch (error) {
+      // Parsing failed - likely preprocessor syntax (LESS/SASS/Stylus)
+      parseError = error;
+      rules = []; // Clear any partial parse
+    }
+
+    // Restore position to after the closing }
+    this.pos = savedPos;
+
+    return new ASTNode(NodeType.StyleBlock, {
+      rules,
+      raw: rawCSS,
+      parseError: parseError ? parseError.message : null
+    });
+  }
+
+  /**
+   * Reconstruct CSS from tokens, preserving formatting
+   */
+  reconstructCSS(tokens) {
+    if (!tokens.length) return '';
+
+    const lines = [];
+    let currentLine = [];
+    let lastLine = tokens[0].line;
+
+    for (const token of tokens) {
+      if (token.line !== lastLine) {
+        lines.push(currentLine.join(''));
+        currentLine = [];
+        lastLine = token.line;
+      }
+      currentLine.push(token.raw || token.value);
+    }
+
+    if (currentLine.length > 0) {
+      lines.push(currentLine.join(''));
+    }
+
+    return lines.join('\n').trim();
   }
 
   /**