pulse-js-framework 1.7.5 → 1.7.8

package/cli/index.js

@@ -5,9 +5,10 @@
  */
 
 import { fileURLToPath } from 'url';
-import { dirname, join, resolve } from 'path';
-import { existsSync, mkdirSync, writeFileSync, readFileSync, cpSync } from 'fs';
+import { dirname, join, resolve, relative } from 'path';
+import { existsSync, mkdirSync, writeFileSync, readFileSync, cpSync, watch } from 'fs';
 import { log } from './logger.js';
+import { findPulseFiles, parseArgs } from './utils/file-utils.js';
 
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
@@ -24,14 +25,98 @@ const commands = {
   dev: runDev,
   build: runBuild,
   preview: runPreview,
-  compile: compileFile,
+  compile: compileFiles,
   mobile: runMobile,
   lint: runLint,
   format: runFormat,
   analyze: runAnalyze,
-  release: runReleaseCmd
+  release: runReleaseCmd,
+  'docs-test': runDocsTestCmd
 };
 
+// Command aliases for common typos
+const commandAliases = {
+  'complile': 'compile',
+  'comile': 'compile',
+  'complie': 'compile',
+  'buid': 'build',
+  'biuld': 'build',
+  'buildd': 'build',
+  'devv': 'dev',
+  'lnt': 'lint',
+  'lintt': 'lint',
+  'fromat': 'format',
+  'foramt': 'format',
+  'formatt': 'format',
+  'analize': 'analyze',
+  'analzye': 'analyze',
+  'anaylze': 'analyze',
+  'crate': 'create',
+  'craete': 'create',
+  'preivew': 'preview',
+  'preveiw': 'preview',
+  'moble': 'mobile',
+  'moblie': 'mobile',
+  'relase': 'release',
+  'realease': 'release'
+};
+
+/**
+ * Calculate Levenshtein distance between two strings
+ * Used for "Did you mean...?" suggestions
+ */
+function levenshteinDistance(a, b) {
+  const matrix = [];
+
+  for (let i = 0; i <= b.length; i++) {
+    matrix[i] = [i];
+  }
+  for (let j = 0; j <= a.length; j++) {
+    matrix[0][j] = j;
+  }
+
+  for (let i = 1; i <= b.length; i++) {
+    for (let j = 1; j <= a.length; j++) {
+      if (b.charAt(i - 1) === a.charAt(j - 1)) {
+        matrix[i][j] = matrix[i - 1][j - 1];
+      } else {
+        matrix[i][j] = Math.min(
+          matrix[i - 1][j - 1] + 1,
+          matrix[i][j - 1] + 1,
+          matrix[i - 1][j] + 1
+        );
+      }
+    }
+  }
+
+  return matrix[b.length][a.length];
+}
+
+/**
+ * Suggest similar commands based on input
+ */
+function suggestCommand(input) {
+  // Check aliases first
+  if (input in commandAliases) {
+    return commandAliases[input];
+  }
+
+  // Find closest command using Levenshtein distance
+  const allCommands = Object.keys(commands);
+  let closest = null;
+  let minDistance = Infinity;
+
+  for (const cmd of allCommands) {
+    const distance = levenshteinDistance(input.toLowerCase(), cmd.toLowerCase());
+    if (distance < minDistance && distance <= 3) { // Max 3 edits
+      minDistance = distance;
+      closest = cmd;
+    }
+  }
+
+  return closest;
+}
+
 /**
  * Main entry point
  */
@@ -43,6 +128,13 @@ async function main() {
     await commands[command](args.slice(1));
   } else {
     log.error(`Unknown command: ${command}`);
+
+    // Try to suggest a similar command
+    const suggestion = suggestCommand(command);
+    if (suggestion) {
+      log.info(`Did you mean: pulse ${suggestion}?`);
+    }
+
     log.info('Run "pulse help" for usage information.');
     process.exit(1);
   }
@@ -68,14 +160,23 @@ Commands:
   format [files]   Format .pulse files consistently
   analyze          Analyze bundle size and dependencies
   release <type>   Create a new release (patch, minor, major)
+  docs-test        Test documentation (syntax, imports, HTTP)
   version          Show version number
   help             Show this help message
 
+Compile Options:
+  --watch, -w      Watch files and recompile on changes
+  --dry-run        Show what would be compiled without writing
+  --output, -o     Output directory (default: same as input)
+
 Lint Options:
   --fix            Auto-fix fixable issues
+  --watch, -w      Watch files and re-lint on changes
+  --dry-run        Show fixes without applying (use with --fix)
 
 Format Options:
-  --check          Check formatting without writing
+  --check          Check formatting without writing (dry-run)
+  --watch, -w      Watch files and re-format on changes
   --write          Write formatted output (default)
 
 Analyze Options:
@@ -83,11 +184,16 @@ Analyze Options:
   --verbose        Show detailed metrics
 
 Release 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 for changelog
-  --skip-prompt    Use empty changelog (for automation)
-  --from-commits   Auto-extract changelog from git commits since last tag
+  --dry-run         Show what would be done without making changes
+  --no-push         Create commit and tag but don't push
+  --title <text>    Release title for changelog
+  --skip-prompt     Use empty changelog (for automation)
+  --skip-docs-test  Skip documentation tests before release
+  --from-commits    Auto-extract changelog from git commits since last tag
+
+Docs-test Options:
+  --verbose, -v    Show detailed output
+  --no-http        Skip HTTP server tests
 
 Examples:
   pulse create my-app
@@ -99,7 +205,10 @@ Examples:
   pulse mobile build android
   pulse mobile run ios
   pulse compile src/App.pulse
+  pulse compile src/ --watch
+  pulse compile "**/*.pulse" --dry-run
   pulse lint src/
+  pulse lint src/ --fix --dry-run
   pulse lint "**/*.pulse" --fix
   pulse format --check
   pulse format src/App.pulse
@@ -109,6 +218,8 @@ Examples:
   pulse release minor --title "New Features"
   pulse release major --dry-run
   pulse release patch --from-commits
+  pulse docs-test
+  pulse docs-test --verbose
 
 Documentation: https://github.com/vincenthirtz/pulse-js-framework
   `);
@@ -381,38 +492,209 @@ async function runReleaseCmd(args) {
 }
 
 /**
- * Compile a single .pulse file
+ * Run documentation tests
  */
-async function compileFile(args) {
-  const inputFile = args[0];
+async function runDocsTestCmd(args) {
+  const { runDocsTestCli } = await import('./docs-test.js');
+  await runDocsTestCli(args);
+}
 
-  if (!inputFile) {
-    log.error('Please provide a file to compile.');
-    log.info('Usage: pulse compile <file.pulse>');
+/**
+ * Compile .pulse files to JavaScript
+ * Supports multiple files, watch mode, and dry-run
+ */
+async function compileFiles(args) {
+  const { options, patterns } = parseArgs(args);
+  const watchMode = options.watch || options.w || false;
+  const dryRun = options['dry-run'] || false;
+  const outputDir = options.output || options.o || null;
+
+  // Find all .pulse files matching patterns
+  const files = findPulseFiles(patterns);
+
+  if (files.length === 0) {
+    log.error('No .pulse files found.');
+    log.info('Usage: pulse compile <file.pulse> [options]');
+    log.info('       pulse compile src/ --watch');
     process.exit(1);
   }
 
-  if (!existsSync(inputFile)) {
-    log.error(`File not found: ${inputFile}`);
-    process.exit(1);
+  const { compile } = await import('../compiler/index.js');
+  const cwd = process.cwd();
+
+  /**
+   * Compile a single file and return result
+   */
+  function compileOneFile(inputFile) {
+    const relPath = relative(cwd, inputFile);
+    const source = readFileSync(inputFile, 'utf-8');
+    const result = compile(source);
+
+    // Determine output path
+    let outputFile;
+    if (outputDir) {
+      const baseName = inputFile.replace(/\.pulse$/, '.js').split(/[/\\]/).pop();
+      outputFile = join(outputDir, baseName);
+    } else {
+      outputFile = inputFile.replace(/\.pulse$/, '.js');
+    }
+    const relOutput = relative(cwd, outputFile);
+
+    return { inputFile, outputFile, relPath, relOutput, result, source };
   }
 
-  const { compile } = await import('../compiler/index.js');
+  /**
+   * Process compilation results
+   */
+  function processResults(compilations) {
+    let successCount = 0;
+    let errorCount = 0;
+
+    for (const { relPath, relOutput, result } of compilations) {
+      if (result.success) {
+        successCount++;
+      } else {
+        errorCount++;
+        log.error(`\n${relPath}:`);
+        for (const error of result.errors) {
+          const loc = error.line ? `:${error.line}:${error.column || 1}` : '';
+          log.error(`  ${relPath}${loc} ${error.message}`);
+        }
+      }
+    }
 
-  const source = readFileSync(inputFile, 'utf-8');
-  const result = compile(source);
+    return { successCount, errorCount };
+  }
 
-  if (result.success) {
-    const outputFile = inputFile.replace(/\.pulse$/, '.js');
-    writeFileSync(outputFile, result.code);
-    log.info(`Compiled: ${inputFile} -> ${outputFile}`);
-  } else {
-    log.error('Compilation failed:');
-    for (const error of result.errors) {
-      log.error(`  ${error.message}`);
+  /**
+   * Run compilation on all files
+   */
+  async function runCompilation() {
+    const startTime = Date.now();
+    const compilations = files.map(compileOneFile);
+    const { successCount, errorCount } = processResults(compilations);
+
+    if (dryRun) {
+      // Dry run - show what would be done
+      log.info('\n[Dry Run] Would compile:');
+      for (const { relPath, relOutput, result } of compilations) {
+        if (result.success) {
+          log.info(`  ${relPath} -> ${relOutput}`);
+        }
+      }
+      log.info(`\n${successCount} file(s) would be compiled, ${errorCount} error(s)`);
+    } else {
+      // Actually write files
+      let writtenCount = 0;
+      for (const { outputFile, relPath, relOutput, result } of compilations) {
+        if (result.success) {
+          // Ensure output directory exists
+          const outDir = dirname(outputFile);
+          if (!existsSync(outDir)) {
+            mkdirSync(outDir, { recursive: true });
+          }
+          writeFileSync(outputFile, result.code);
+          log.info(`Compiled: ${relPath} -> ${relOutput}`);
+          writtenCount++;
+        }
+      }
+
+      const duration = Date.now() - startTime;
+      if (files.length > 1) {
+        log.info(`\n${writtenCount} file(s) compiled in ${duration}ms`);
+        if (errorCount > 0) {
+          log.error(`${errorCount} file(s) failed`);
+        }
+      }
     }
-    process.exit(1);
+
+    return errorCount === 0;
+  }
+
+  // Initial compilation
+  const success = await runCompilation();
+
+  if (!watchMode) {
+    if (!success) {
+      process.exit(1);
+    }
+    return;
   }
+
+  // Watch mode
+  log.info('\nWatching for changes... (Ctrl+C to stop)\n');
+
+  // Collect directories to watch
+  const dirsToWatch = new Set();
+  for (const file of files) {
+    dirsToWatch.add(dirname(file));
+  }
+
+  // Debounce mechanism
+  let debounceTimeout = null;
+  const changedFiles = new Set();
+
+  function handleChange(eventType, filename) {
+    if (!filename || !filename.endsWith('.pulse')) return;
+
+    // Find the full path of the changed file
+    for (const dir of dirsToWatch) {
+      const fullPath = join(dir, filename);
+      if (files.includes(fullPath)) {
+        changedFiles.add(fullPath);
+        break;
+      }
+    }
+
+    // Debounce: wait 100ms before processing
+    if (debounceTimeout) {
+      clearTimeout(debounceTimeout);
+    }
+    debounceTimeout = setTimeout(() => {
+      if (changedFiles.size > 0) {
+        log.info(`\nFile changed: ${[...changedFiles].map(f => relative(cwd, f)).join(', ')}`);
+        const filesToCompile = [...changedFiles];
+        changedFiles.clear();
+
+        // Recompile changed files
+        for (const file of filesToCompile) {
+          const { relPath, relOutput, outputFile, result } = compileOneFile(file);
+          if (result.success) {
+            if (!dryRun) {
+              writeFileSync(outputFile, result.code);
+            }
+            log.info(`${dryRun ? '[Dry Run] Would compile' : 'Compiled'}: ${relPath} -> ${relOutput}`);
+          } else {
+            log.error(`\n${relPath}:`);
+            for (const error of result.errors) {
+              const loc = error.line ? `:${error.line}:${error.column || 1}` : '';
+              log.error(`  ${relPath}${loc} ${error.message}`);
+            }
+          }
+        }
+      }
+    }, 100);
+  }
+
+  // Start watching directories
+  const watchers = [];
+  for (const dir of dirsToWatch) {
+    try {
+      const watcher = watch(dir, { recursive: false }, handleChange);
+      watchers.push(watcher);
+    } catch (e) {
+      log.warn(`Could not watch directory: ${dir}`);
+    }
+  }
+
+  // Keep process running
+  process.on('SIGINT', () => {
+    log.info('\nStopping watch mode...');
+    for (const watcher of watchers) {
+      watcher.close();
+    }
+    process.exit(0);
+  });
 }
 
 // Run main

package/cli/lint.js

@@ -706,10 +706,13 @@ export async function lintFile(filePath, options = {}) {
  * Lint files and return summary
  * @param {string[]} files - Files to lint
  * @param {Object} options - Lint options
+ * @param {boolean} options.fix - Auto-fix issues
+ * @param {boolean} options.dryRun - Show fixes without applying
+ * @param {boolean} options.quiet - Suppress output
  * @returns {Object} Summary with totals
  */
 async function lintFiles(files, options = {}) {
-  const { fix = false, quiet = false } = options;
+  const { fix = false, dryRun = false, quiet = false } = options;
   const timer = createTimer();
 
   let totalErrors = 0;
@@ -749,8 +752,14 @@ async function lintFiles(files, options = {}) {
 export async function runLint(args) {
   const { options, patterns } = parseArgs(args);
   const fix = options.fix || false;
+  const dryRun = options['dry-run'] || false;
   const watchMode = options.watch || options.w || false;
 
+  // Dry-run only makes sense with --fix
+  if (dryRun && !fix) {
+    log.warn('Note: --dry-run has no effect without --fix');
+  }
+
   // Find files to lint
   const files = findPulseFiles(patterns);
 
@@ -760,8 +769,8 @@ export async function runLint(args) {
   }
 
   // Initial lint run
-  log.info(`Linting ${files.length} file(s)...\n`);
-  const summary = await lintFiles(files, { fix });
+  log.info(`Linting ${files.length} file(s)...${dryRun ? ' (dry-run)' : ''}\n`);
+  const summary = await lintFiles(files, { fix, dryRun });
 
   // Print summary
   printLintSummary(summary, files.length);
@@ -795,7 +804,7 @@ export async function runLint(args) {
           debounceTimers.delete(filePath);
 
           log.info(`\n[${new Date().toLocaleTimeString()}] File changed: ${relativePath(filePath)}`);
-          lintFiles([filePath], { fix }).then(result => {
+          lintFiles([filePath], { fix, dryRun }).then(result => {
             printLintSummary(result, 1, true);
           });
         }, 100));

package/cli/logger.js

@@ -1,9 +1,14 @@
 /**
  * Pulse CLI Logger
- * Lightweight logger for CLI tools with support for verbose mode
+ * Adapter for CLI tools using the unified runtime logger
  * @module pulse-cli/logger
  */
 
+import { createLogger, setLogLevel, LogLevel } from '../runtime/logger.js';
+
+// Create CLI-namespaced logger
+const cliLogger = createLogger('CLI');
+
 /** @type {boolean} */
 let verboseMode = false;
 
@@ -17,6 +22,12 @@ let verboseMode = false;
  */
 export function setVerbose(enabled) {
   verboseMode = enabled;
+  // Update global log level to include debug when verbose
+  if (enabled) {
+    setLogLevel(LogLevel.DEBUG);
+  } else {
+    setLogLevel(LogLevel.INFO);
+  }
 }
 
 /**
@@ -33,6 +44,7 @@ export function isVerbose() {
 
 /**
  * CLI Logger object with console-like API
+ * Uses the runtime logger under the hood for consistency
  * @namespace log
  */
 export const log = {
@@ -44,6 +56,7 @@ export const log = {
    * log.info('Starting server on port', 3000);
    */
   info(...args) {
+    // Use console directly for CLI output (no namespace prefix for info)
     console.log(...args);
   },
 
@@ -66,7 +79,7 @@ export const log = {
    * log.warn('Deprecated feature used');
    */
   warn(...args) {
-    console.warn(...args);
+    cliLogger.warn(...args);
   },
 
   /**
@@ -77,7 +90,7 @@ export const log = {
    * log.error('Failed to compile:', error.message);
    */
   error(...args) {
-    console.error(...args);
+    cliLogger.error(...args);
   },
 
   /**
@@ -89,7 +102,7 @@ export const log = {
    */
   debug(...args) {
     if (verboseMode) {
-      console.log('[debug]', ...args);
+      cliLogger.debug(...args);
     }
   },
 
@@ -116,7 +129,22 @@ export const log = {
    */
   newline() {
     console.log();
+  },
+
+  /**
+   * Create a child logger with a sub-namespace
+   * @param {string} namespace - Child namespace
+   * @returns {import('../runtime/logger.js').Logger} Child logger instance
+   * @example
+   * const buildLog = log.child('Build');
+   * buildLog.info('Starting...'); // [CLI:Build] Starting...
+   */
+  child(namespace) {
+    return cliLogger.child(namespace);
   }
 };
 
+// Re-export LogLevel for convenience
+export { LogLevel };
+
 export default log;

package/cli/release.js

@@ -10,13 +10,15 @@
  * - Push to remote
  */
 
-import { readFileSync, writeFileSync, existsSync } from 'fs';
+import { readFileSync, writeFileSync, existsSync, unlinkSync } from 'fs';
 import { join, dirname } from 'path';
 import { fileURLToPath } from 'url';
 import { execSync } from 'child_process';
+import { tmpdir } from 'os';
 import { createInterface } from 'readline';
 import https from 'https';
 import { log } from './logger.js';
+import { runDocsTest } from './docs-test.js';
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
 const root = join(__dirname, '..');
@@ -525,14 +527,15 @@ function gitCommitTagPush(newVersion, title, changes, dryRun = false) {
   log.info('  Running: git add -A...');
   execSync('git add -A', { cwd: root, stdio: 'inherit' });
 
-  // git commit with heredoc for proper message formatting
+  // git commit using temp file for cross-platform compatibility
   log.info('  Running: git commit...');
-  const escapedMessage = commitMessage.replace(/'/g, "'\\''");
-  execSync(`git commit -m $'${escapedMessage.replace(/\n/g, '\\n')}'`, {
-    cwd: root,
-    stdio: 'inherit',
-    shell: '/bin/bash'
-  });
+  const tempFile = join(tmpdir(), `pulse-release-${Date.now()}.txt`);
+  writeFileSync(tempFile, commitMessage, 'utf-8');
+  try {
+    execSync(`git commit -F "${tempFile}"`, { cwd: root, stdio: 'inherit' });
+  } finally {
+    unlinkSync(tempFile);
+  }
 
   // git tag
   log.info(`  Running: git tag v${newVersion}...`);
@@ -559,12 +562,13 @@ Types:
   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)
-  --from-commits   Auto-extract changelog from git commits since last tag
-  --yes, -y        Auto-confirm all prompts
+  --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)
+  --skip-docs-test  Skip documentation validation before release
+  --from-commits    Auto-extract changelog from git commits since last tag
+  --yes, -y         Auto-confirm all prompts
   --changes <json> Pass changelog as JSON (e.g., '{"added":["Feature 1"],"fixed":["Bug 1"]}')
   --added <items>  Comma-separated list of added features
   --changed <items> Comma-separated list of changes
@@ -599,6 +603,7 @@ export async function runRelease(args) {
   const skipPrompt = args.includes('--skip-prompt');
   const fromCommits = args.includes('--from-commits');
   const autoConfirm = args.includes('--yes') || args.includes('-y');
+  const skipDocsTest = args.includes('--skip-docs-test');
 
   let title = '';
   const titleIndex = args.indexOf('--title');
@@ -675,6 +680,30 @@ export async function runRelease(args) {
     process.exit(1);
   }
 
+  // Run documentation tests
+  if (!skipDocsTest) {
+    log.info('');
+    log.info('Running documentation tests...');
+
+    const docsTestResult = await runDocsTest({ verbose: false, httpTest: true });
+
+    if (!docsTestResult.success) {
+      log.error('Documentation tests failed. Fix errors before releasing.');
+      if (!autoConfirm) {
+        const proceed = await prompt('Continue anyway? (y/N) ');
+        if (proceed.toLowerCase() !== 'y') {
+          log.info('Aborted.');
+          process.exit(1);
+        }
+      } else {
+        log.error('Aborting release due to documentation errors.');
+        process.exit(1);
+      }
+    }
+  } else {
+    log.warn('Skipping documentation tests (--skip-docs-test)');
+  }
+
   // Collect changelog entries
   let changes = { added: [], changed: [], fixed: [], removed: [] };
 
@@ -786,12 +815,13 @@ export async function runRelease(args) {
       // Only commit and tag, no push
       const commitMessage = buildCommitMessage(newVersion, title, changes);
       execSync('git add -A', { cwd: root, stdio: 'inherit' });
-      const escapedMessage = commitMessage.replace(/'/g, "'\\''");
-      execSync(`git commit -m $'${escapedMessage.replace(/\n/g, '\\n')}'`, {
-        cwd: root,
-        stdio: 'inherit',
-        shell: '/bin/bash'
-      });
+      const tempFile = join(tmpdir(), `pulse-release-${Date.now()}.txt`);
+      writeFileSync(tempFile, commitMessage, 'utf-8');
+      try {
+        execSync(`git commit -F "${tempFile}"`, { cwd: root, stdio: 'inherit' });
+      } finally {
+        unlinkSync(tempFile);
+      }
       execSync(`git tag -a v${newVersion} -m "Release v${newVersion}"`, { cwd: root, stdio: 'inherit' });
       log.info('  Created commit and tag (--no-push specified)');
     } else {

package/compiler/parser.js

@@ -5,7 +5,7 @@
  */
 
 import { TokenType, tokenize } from './lexer.js';
-import { ParserError, SUGGESTIONS, getDocsUrl } from '../core/errors.js';
+import { ParserError, SUGGESTIONS, getDocsUrl } from '../runtime/errors.js';
 
 // AST Node types
 export const NodeType = {