pulse-js-framework 1.4.9 → 1.5.0

package/cli/release.js

@@ -0,0 +1,493 @@
+/**
+ * Pulse CLI - Release Command
+ *
+ * Handles version bumping and release automation:
+ * - Bump version (patch, minor, major)
+ * - Update CHANGELOG.md
+ * - Update docs changelog page
+ * - Update version in docs state
+ * - Create git commit and tag
+ * - Push to remote
+ */
+
+import { readFileSync, writeFileSync, existsSync } from 'fs';
+import { join, dirname } from 'path';
+import { fileURLToPath } from 'url';
+import { execSync } from 'child_process';
+import { createInterface } from 'readline';
+import { log } from './logger.js';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const root = join(__dirname, '..');
+
+/**
+ * Prompt user for input
+ */
+function prompt(question) {
+  const rl = createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+
+  return new Promise((resolve) => {
+    rl.question(question, (answer) => {
+      rl.close();
+      resolve(answer);
+    });
+  });
+}
+
+/**
+ * Prompt for multiline input
+ */
+async function promptMultiline(question) {
+  log.info(question);
+  log.info('(Enter each item on a new line, empty line to finish)');
+
+  const rl = createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+
+  const lines = [];
+
+  return new Promise((resolve) => {
+    rl.on('line', (line) => {
+      if (line.trim() === '') {
+        rl.close();
+        resolve(lines);
+      } else {
+        lines.push(line.trim());
+      }
+    });
+  });
+}
+
+/**
+ * Parse version string
+ */
+function parseVersion(version) {
+  const match = version.match(/^(\d+)\.(\d+)\.(\d+)$/);
+  if (!match) throw new Error(`Invalid version format: ${version}`);
+  return {
+    major: parseInt(match[1], 10),
+    minor: parseInt(match[2], 10),
+    patch: parseInt(match[3], 10)
+  };
+}
+
+/**
+ * Bump version based on type
+ */
+function bumpVersion(version, type) {
+  const v = parseVersion(version);
+  switch (type) {
+    case 'major':
+      return `${v.major + 1}.0.0`;
+    case 'minor':
+      return `${v.major}.${v.minor + 1}.0`;
+    case 'patch':
+      return `${v.major}.${v.minor}.${v.patch + 1}`;
+    default:
+      throw new Error(`Unknown version type: ${type}`);
+  }
+}
+
+/**
+ * Get current date in YYYY-MM-DD format
+ */
+function getCurrentDate() {
+  const now = new Date();
+  return now.toISOString().split('T')[0];
+}
+
+/**
+ * Get current month and year
+ */
+function getCurrentMonthYear() {
+  const months = [
+    'January', 'February', 'March', 'April', 'May', 'June',
+    'July', 'August', 'September', 'October', 'November', 'December'
+  ];
+  const now = new Date();
+  return `${months[now.getMonth()]} ${now.getFullYear()}`;
+}
+
+/**
+ * Update package.json version
+ */
+function updatePackageJson(newVersion) {
+  const pkgPath = join(root, 'package.json');
+  const pkg = JSON.parse(readFileSync(pkgPath, 'utf-8'));
+  pkg.version = newVersion;
+  writeFileSync(pkgPath, JSON.stringify(pkg, null, 2) + '\n');
+  log.info(`  Updated package.json to v${newVersion}`);
+}
+
+/**
+ * Update docs/src/state.js version
+ */
+function updateDocsState(newVersion) {
+  const statePath = join(root, 'docs/src/state.js');
+  if (!existsSync(statePath)) {
+    log.warn('  docs/src/state.js not found, skipping');
+    return;
+  }
+
+  let content = readFileSync(statePath, 'utf-8');
+  content = content.replace(
+    /export const version = '[^']+'/,
+    `export const version = '${newVersion}'`
+  );
+  writeFileSync(statePath, content);
+  log.info(`  Updated docs/src/state.js to v${newVersion}`);
+}
+
+/**
+ * Update CHANGELOG.md
+ */
+function updateChangelog(newVersion, title, changes) {
+  const changelogPath = join(root, 'CHANGELOG.md');
+  if (!existsSync(changelogPath)) {
+    log.warn('  CHANGELOG.md not found, skipping');
+    return;
+  }
+
+  let content = readFileSync(changelogPath, 'utf-8');
+
+  // Build changelog entry
+  const date = getCurrentDate();
+  let entry = `## [${newVersion}] - ${date}\n\n`;
+
+  if (title) {
+    entry += `### ${title}\n\n`;
+  }
+
+  if (changes.added && changes.added.length > 0) {
+    entry += `### Added\n\n`;
+    for (const item of changes.added) {
+      entry += `- ${item}\n`;
+    }
+    entry += '\n';
+  }
+
+  if (changes.changed && changes.changed.length > 0) {
+    entry += `### Changed\n\n`;
+    for (const item of changes.changed) {
+      entry += `- ${item}\n`;
+    }
+    entry += '\n';
+  }
+
+  if (changes.fixed && changes.fixed.length > 0) {
+    entry += `### Fixed\n\n`;
+    for (const item of changes.fixed) {
+      entry += `- ${item}\n`;
+    }
+    entry += '\n';
+  }
+
+  if (changes.removed && changes.removed.length > 0) {
+    entry += `### Removed\n\n`;
+    for (const item of changes.removed) {
+      entry += `- ${item}\n`;
+    }
+    entry += '\n';
+  }
+
+  // Insert after the header section (after line 6)
+  const lines = content.split('\n');
+  const insertIndex = lines.findIndex(line => line.startsWith('## ['));
+
+  if (insertIndex !== -1) {
+    lines.splice(insertIndex, 0, entry);
+  } else {
+    // No existing version entries, add after header
+    lines.push(entry);
+  }
+
+  writeFileSync(changelogPath, lines.join('\n'));
+  log.info(`  Updated CHANGELOG.md with v${newVersion}`);
+}
+
+/**
+ * Update docs changelog page
+ */
+function updateDocsChangelog(newVersion, title, changes) {
+  const changelogPagePath = join(root, 'docs/src/pages/ChangelogPage.js');
+  if (!existsSync(changelogPagePath)) {
+    log.warn('  docs/src/pages/ChangelogPage.js not found, skipping');
+    return;
+  }
+
+  let content = readFileSync(changelogPagePath, 'utf-8');
+  const monthYear = getCurrentMonthYear();
+
+  // Build HTML changelog section
+  let section = `
+    <section class="doc-section changelog-section">
+      <h2>v${newVersion} - ${title || 'Release'}</h2>
+      <p class="release-date">${monthYear}</p>
+
+      <div class="changelog-group">`;
+
+  // Combine all changes into feature list
+  const allChanges = [
+    ...(changes.added || []).map(c => `<strong>Added:</strong> ${escapeHtml(c)}`),
+    ...(changes.changed || []).map(c => `<strong>Changed:</strong> ${escapeHtml(c)}`),
+    ...(changes.fixed || []).map(c => `<strong>Fixed:</strong> ${escapeHtml(c)}`),
+    ...(changes.removed || []).map(c => `<strong>Removed:</strong> ${escapeHtml(c)}`)
+  ];
+
+  if (allChanges.length > 0) {
+    section += `
+        <ul class="feature-list">`;
+    for (const change of allChanges) {
+      section += `
+          <li>${change}</li>`;
+    }
+    section += `
+        </ul>`;
+  }
+
+  section += `
+      </div>
+    </section>
+`;
+
+  // Find where to insert (after the intro paragraph, before first section)
+  const insertMarker = '<section class="doc-section changelog-section">';
+  const insertIndex = content.indexOf(insertMarker);
+
+  if (insertIndex !== -1) {
+    content = content.slice(0, insertIndex) + section + content.slice(insertIndex);
+  }
+
+  writeFileSync(changelogPagePath, content);
+  log.info(`  Updated docs/src/pages/ChangelogPage.js with v${newVersion}`);
+}
+
+/**
+ * Escape HTML entities
+ */
+function escapeHtml(str) {
+  return str
+    .replace(/&/g, '&amp;')
+    .replace(/</g, '&lt;')
+    .replace(/>/g, '&gt;')
+    .replace(/"/g, '&quot;');
+}
+
+/**
+ * Update CLAUDE.md if needed
+ */
+function updateClaudeMd(newVersion) {
+  // CLAUDE.md reads version from package.json, so no update needed
+  log.info('  CLAUDE.md reads version from package.json (no update needed)');
+}
+
+/**
+ * Update README.md if needed
+ */
+function updateReadme(newVersion) {
+  // README.md doesn't have a version number to update
+  // But we could update version-specific feature mentions if needed
+  log.info('  README.md has no version-specific content to update');
+}
+
+/**
+ * Execute git commands
+ */
+function gitCommitTagPush(newVersion, dryRun = false) {
+  const commands = [
+    'git add -A',
+    `git commit -m "$(cat <<'EOF'\nv${newVersion}\n\nCo-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>\nEOF\n)"`,
+    `git tag -a v${newVersion} -m "Release v${newVersion}"`,
+    'git push',
+    'git push --tags'
+  ];
+
+  for (const cmd of commands) {
+    if (dryRun) {
+      log.info(`  [dry-run] ${cmd}`);
+    } else {
+      log.info(`  Running: ${cmd.split('\n')[0]}...`);
+      try {
+        execSync(cmd, { cwd: root, stdio: 'inherit', shell: '/bin/bash' });
+      } catch (error) {
+        log.error(`  Failed: ${error.message}`);
+        throw error;
+      }
+    }
+  }
+}
+
+/**
+ * Show usage
+ */
+function showUsage() {
+  log.info(`
+Usage: pulse release <type> [options]
+
+Types:
+  patch     Bump patch version (1.0.0 -> 1.0.1)
+  minor     Bump minor version (1.0.0 -> 1.1.0)
+  major     Bump major version (1.0.0 -> 2.0.0)
+
+Options:
+  --dry-run       Show what would be done without making changes
+  --no-push       Create commit and tag but don't push
+  --title <text>  Release title (e.g., "Performance Improvements")
+  --skip-prompt   Use empty changelog (for automated releases)
+
+Examples:
+  pulse release patch
+  pulse release minor --title "New Features"
+  pulse release major --dry-run
+  `);
+}
+
+/**
+ * Main release command
+ */
+export async function runRelease(args) {
+  const type = args[0];
+
+  if (!type || !['patch', 'minor', 'major'].includes(type)) {
+    showUsage();
+    process.exit(1);
+  }
+
+  // Parse options
+  const dryRun = args.includes('--dry-run');
+  const noPush = args.includes('--no-push');
+  const skipPrompt = args.includes('--skip-prompt');
+
+  let title = '';
+  const titleIndex = args.indexOf('--title');
+  if (titleIndex !== -1 && args[titleIndex + 1]) {
+    title = args[titleIndex + 1];
+  }
+
+  // Read current version
+  const pkg = JSON.parse(readFileSync(join(root, 'package.json'), 'utf-8'));
+  const currentVersion = pkg.version;
+  const newVersion = bumpVersion(currentVersion, type);
+
+  log.info('');
+  log.info(`Pulse Release: v${currentVersion} -> v${newVersion}`);
+  log.info('='.repeat(50));
+
+  if (dryRun) {
+    log.warn('DRY RUN - No changes will be made');
+    log.info('');
+  }
+
+  // Check for uncommitted changes
+  try {
+    const status = execSync('git status --porcelain', { cwd: root, encoding: 'utf-8' });
+    if (status.trim()) {
+      log.warn('You have uncommitted changes:');
+      log.info(status);
+      const proceed = await prompt('Continue anyway? (y/N) ');
+      if (proceed.toLowerCase() !== 'y') {
+        log.info('Aborted.');
+        process.exit(0);
+      }
+    }
+  } catch (error) {
+    log.error('Failed to check git status');
+    process.exit(1);
+  }
+
+  // Collect changelog entries
+  let changes = { added: [], changed: [], fixed: [], removed: [] };
+
+  if (!skipPrompt) {
+    if (!title) {
+      title = await prompt('Release title (e.g., "Performance Improvements"): ');
+    }
+
+    log.info('');
+    log.info('Enter changelog items (leave empty to skip category):');
+    log.info('');
+
+    changes.added = await promptMultiline('Added (new features):');
+    changes.changed = await promptMultiline('Changed (modifications):');
+    changes.fixed = await promptMultiline('Fixed (bug fixes):');
+    changes.removed = await promptMultiline('Removed (deprecated features):');
+  }
+
+  const hasChanges = Object.values(changes).some(arr => arr.length > 0);
+
+  if (!hasChanges && !skipPrompt) {
+    const proceed = await prompt('No changelog entries. Continue? (y/N) ');
+    if (proceed.toLowerCase() !== 'y') {
+      log.info('Aborted.');
+      process.exit(0);
+    }
+  }
+
+  log.info('');
+  log.info('Updating files...');
+
+  if (!dryRun) {
+    // 1. Update package.json
+    updatePackageJson(newVersion);
+
+    // 2. Update docs state
+    updateDocsState(newVersion);
+
+    // 3. Update CHANGELOG.md
+    if (hasChanges) {
+      updateChangelog(newVersion, title, changes);
+    }
+
+    // 4. Update docs changelog page
+    if (hasChanges) {
+      updateDocsChangelog(newVersion, title, changes);
+    }
+
+    // 5. CLAUDE.md and README.md
+    updateClaudeMd(newVersion);
+    updateReadme(newVersion);
+  } else {
+    log.info('  [dry-run] Would update package.json');
+    log.info('  [dry-run] Would update docs/src/state.js');
+    if (hasChanges) {
+      log.info('  [dry-run] Would update CHANGELOG.md');
+      log.info('  [dry-run] Would update docs/src/pages/ChangelogPage.js');
+    }
+  }
+
+  log.info('');
+  log.info('Git operations...');
+
+  if (!dryRun) {
+    if (noPush) {
+      // Only commit and tag, no push
+      execSync('git add -A', { cwd: root, stdio: 'inherit' });
+      execSync(`git commit -m "v${newVersion}\n\nCo-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>"`, {
+        cwd: root,
+        stdio: 'inherit',
+        shell: '/bin/bash'
+      });
+      execSync(`git tag -a v${newVersion} -m "Release v${newVersion}"`, { cwd: root, stdio: 'inherit' });
+      log.info('  Created commit and tag (--no-push specified)');
+    } else {
+      gitCommitTagPush(newVersion, false);
+    }
+  } else {
+    gitCommitTagPush(newVersion, true);
+  }
+
+  log.info('');
+  log.info(`Release v${newVersion} complete!`);
+  log.info('');
+
+  if (!dryRun && !noPush) {
+    log.info('Next steps:');
+    log.info(`  1. Create GitHub release: https://github.com/vincenthirtz/pulse-js-framework/releases/new?tag=v${newVersion}`);
+    log.info('  2. Publish to npm: npm publish');
+  }
+}

package/compiler/parser.js

@@ -5,6 +5,7 @@
  */
 
 import { TokenType, tokenize } from './lexer.js';
+import { ParserError, SUGGESTIONS } from '../core/errors.js';
 
 // AST Node types
 export const NodeType = {
@@ -122,9 +123,10 @@ export class Parser {
   expect(type, message = null) {
     if (!this.is(type)) {
       const token = this.current();
-      throw new Error(
-        message ||
-        `Expected ${type} but got ${token?.type} at line ${token?.line}:${token?.column}`
+      throw this.createError(
+        message || `Expected ${type} but got ${token?.type}`,
+        token,
+        { suggestion: SUGGESTIONS['unexpected-token']?.(type, token?.type) }
       );
     }
     return this.advance();
@@ -132,14 +134,19 @@ export class Parser {
 
   /**
    * Create a parse error with detailed information
+   * @param {string} message - Error message
+   * @param {Object} [token] - Token where error occurred
+   * @param {Object} [options] - Additional options (suggestion, code)
+   * @returns {ParserError} The parser error
    */
-  createError(message, token = null) {
+  createError(message, token = null, options = {}) {
     const t = token || this.current();
-    const error = new Error(message);
-    error.line = t?.line || 1;
-    error.column = t?.column || 1;
-    error.token = t;
-    return error;
+    return new ParserError(message, {
+      line: t?.line || 1,
+      column: t?.column || 1,
+      token: t,
+      ...options
+    });
   }
 
   /**
@@ -180,49 +187,63 @@ export class Parser {
       // Props block
       else if (this.is(TokenType.PROPS)) {
         if (program.props) {
-          throw this.createError('Duplicate props block - only one props block allowed per file');
+          throw this.createError('Duplicate props block - only one props block allowed per file', null, {
+            suggestion: SUGGESTIONS['duplicate-declaration']?.('props')
+          });
         }
         program.props = this.parsePropsBlock();
       }
       // State block
       else if (this.is(TokenType.STATE)) {
         if (program.state) {
-          throw this.createError('Duplicate state block - only one state block allowed per file');
+          throw this.createError('Duplicate state block - only one state block allowed per file', null, {
+            suggestion: SUGGESTIONS['duplicate-declaration']?.('state')
+          });
         }
         program.state = this.parseStateBlock();
       }
       // View block
       else if (this.is(TokenType.VIEW)) {
         if (program.view) {
-          throw this.createError('Duplicate view block - only one view block allowed per file');
+          throw this.createError('Duplicate view block - only one view block allowed per file', null, {
+            suggestion: SUGGESTIONS['duplicate-declaration']?.('view')
+          });
         }
         program.view = this.parseViewBlock();
       }
       // Actions block
       else if (this.is(TokenType.ACTIONS)) {
         if (program.actions) {
-          throw this.createError('Duplicate actions block - only one actions block allowed per file');
+          throw this.createError('Duplicate actions block - only one actions block allowed per file', null, {
+            suggestion: SUGGESTIONS['duplicate-declaration']?.('actions')
+          });
         }
         program.actions = this.parseActionsBlock();
       }
       // Style block
       else if (this.is(TokenType.STYLE)) {
         if (program.style) {
-          throw this.createError('Duplicate style block - only one style block allowed per file');
+          throw this.createError('Duplicate style block - only one style block allowed per file', null, {
+            suggestion: SUGGESTIONS['duplicate-declaration']?.('style')
+          });
         }
         program.style = this.parseStyleBlock();
       }
       // Router block
       else if (this.is(TokenType.ROUTER)) {
         if (program.router) {
-          throw this.createError('Duplicate router block - only one router block allowed per file');
+          throw this.createError('Duplicate router block - only one router block allowed per file', null, {
+            suggestion: SUGGESTIONS['duplicate-declaration']?.('router')
+          });
         }
         program.router = this.parseRouterBlock();
       }
       // Store block
       else if (this.is(TokenType.STORE)) {
         if (program.store) {
-          throw this.createError('Duplicate store block - only one store block allowed per file');
+          throw this.createError('Duplicate store block - only one store block allowed per file', null, {
+            suggestion: SUGGESTIONS['duplicate-declaration']?.('store')
+          });
         }
         program.store = this.parseStoreBlock();
       }
@@ -415,8 +436,8 @@ export class Parser {
 
     if (this.is(TokenType.IDENT)) return this.parseIdentifierOrExpression();
 
-    throw new Error(
-      `Unexpected token ${this.current()?.type} in value at line ${this.current()?.line}`
+    throw this.createError(
+      `Unexpected token ${this.current()?.type} in value`
     );
   }
 
@@ -1000,8 +1021,8 @@ export class Parser {
       return this.parseIdentifierOrExpression();
     }
 
-    throw new Error(
-      `Unexpected token ${this.current()?.type} in expression at line ${this.current()?.line}`
+    throw this.createError(
+      `Unexpected token ${this.current()?.type} in expression`
     );
   }
 

package/compiler/transformer/constants.js

@@ -0,0 +1,54 @@
+/**
+ * Transformer Constants
+ * Shared constants for the Pulse transformer modules
+ * @module pulse-js-framework/compiler/transformer/constants
+ */
+
+/** Generate a unique scope ID for CSS scoping */
+export const generateScopeId = () => 'p' + Math.random().toString(36).substring(2, 8);
+
+/** Token types that should not have space after them */
+export const NO_SPACE_AFTER = new Set([
+  'DOT', 'LPAREN', 'LBRACKET', 'LBRACE', 'NOT', 'SPREAD',
+  '.', '(', '[', '{', '!', '~', '...'
+]);
+
+/** Token types that should not have space before them */
+export const NO_SPACE_BEFORE = new Set([
+  'DOT', 'RPAREN', 'RBRACKET', 'RBRACE', 'SEMICOLON', 'COMMA',
+  'INCREMENT', 'DECREMENT', 'LPAREN', 'LBRACKET',
+  '.', ')', ']', '}', ';', ',', '++', '--', '(', '['
+]);
+
+/** Punctuation that should not have space before */
+export const PUNCT_NO_SPACE_BEFORE = [
+  'DOT', 'LPAREN', 'RPAREN', 'LBRACKET', 'RBRACKET', 'SEMICOLON', 'COMMA', 'COLON'
+];
+
+/** Punctuation that should not have space after */
+export const PUNCT_NO_SPACE_AFTER = [
+  'DOT', 'LPAREN', 'LBRACKET', 'NOT', 'COLON'
+];
+
+/** JavaScript statement keywords */
+export const STATEMENT_KEYWORDS = new Set([
+  'let', 'const', 'var', 'return', 'if', 'else', 'for', 'while',
+  'switch', 'throw', 'try', 'catch', 'finally'
+]);
+
+/** Built-in JavaScript functions and objects */
+export const BUILTIN_FUNCTIONS = new Set([
+  'setTimeout', 'setInterval', 'clearTimeout', 'clearInterval',
+  'alert', 'confirm', 'prompt', 'console', 'document', 'window',
+  'Math', 'JSON', 'Date', 'Array', 'Object', 'String', 'Number',
+  'Boolean', 'Promise', 'fetch'
+]);
+
+/** Token types that start statements */
+export const STATEMENT_TOKEN_TYPES = new Set(['IF', 'FOR', 'EACH']);
+
+/** Token types that end statements */
+export const STATEMENT_END_TYPES = new Set([
+  'RBRACE', 'RPAREN', 'RBRACKET', 'SEMICOLON', 'STRING',
+  'NUMBER', 'TRUE', 'FALSE', 'NULL', 'IDENT'
+]);