seabox 0.1.1 → 0.2.0

package/lib/build-cache.mjs

@@ -1,199 +1,199 @@
-/**
- * build-cache.mjs
- * Build caching system to speed up incremental builds.
- */
-
-import fs from 'fs';
-import path from 'path';
-import crypto from 'crypto';
-
-/**
- * @typedef {Object} CacheEntry
- * @property {string} hash - Content hash of input
- * @property {number} timestamp - When cached
- * @property {any} data - Cached data
- */
-
-export class BuildCache {
-  /**
-   * @param {string} cacheDir - Cache directory path
-   */
-  constructor(cacheDir = '.seabox-cache') {
-    this.cacheDir = cacheDir;
-    this.ensureCacheDir();
-  }
-
-  /**
-   * Ensure cache directory exists
-   */
-  ensureCacheDir() {
-    if (!fs.existsSync(this.cacheDir)) {
-      fs.mkdirSync(this.cacheDir, { recursive: true });
-    }
-
-    // Create subdirectories
-    const subdirs = ['bundles', 'natives', 'blobs'];
-    for (const subdir of subdirs) {
-      const dirPath = path.join(this.cacheDir, subdir);
-      if (!fs.existsSync(dirPath)) {
-        fs.mkdirSync(dirPath, { recursive: true });
-      }
-    }
-  }
-
-  /**
-   * Compute cache key from entry path and config
-   * @param {string} entryPath - Entry file path
-   * @param {Object} config - Build config
-   * @returns {string}
-   */
-  computeCacheKey(entryPath, config) {
-    const configStr = JSON.stringify({
-      bundler: config.bundler,
-      entry: entryPath
-    });
-    
-    return crypto
-      .createHash('sha256')
-      .update(configStr)
-      .digest('hex')
-      .substring(0, 16);
-  }
-
-  /**
-   * Get cached bundle if valid
-   * @param {string} entryPath - Entry file path
-   * @param {Object} config - Build config
-   * @returns {Object|null}
-   */
-  async getCachedBundle(entryPath, config) {
-    const cacheKey = this.computeCacheKey(entryPath, config);
-    const cachePath = path.join(this.cacheDir, 'bundles', `${cacheKey}.json`);
-
-    if (!fs.existsSync(cachePath)) {
-      return null;
-    }
-
-    try {
-      const cached = JSON.parse(fs.readFileSync(cachePath, 'utf8'));
-      
-      // Validate that source files haven't changed
-      if (await this.isValid(cached, entryPath)) {
-        return cached;
-      }
-    } catch (err) {
-      // Invalid cache entry
-    }
-
-    return null;
-  }
-
-  /**
-   * Cache a bundle result
-   * @param {string} entryPath - Entry file path
-   * @param {Object} config - Build config
-   * @param {Object} bundleResult - Bundle result to cache
-   */
-  async cacheBundle(entryPath, config, bundleResult) {
-    const cacheKey = this.computeCacheKey(entryPath, config);
-    const cachePath = path.join(this.cacheDir, 'bundles', `${cacheKey}.json`);
-
-    const cacheEntry = {
-      hash: await this.hashFile(entryPath),
-      timestamp: Date.now(),
-      data: bundleResult
-    };
-
-    fs.writeFileSync(cachePath, JSON.stringify(cacheEntry, null, 2));
-  }
-
-  /**
-   * Get cached native module build
-   * @param {string} moduleRoot - Module root path
-   * @param {string} target - Build target
-   * @returns {string|null} - Path to cached .node file
-   */
-  getCachedNativeBuild(moduleRoot, target) {
-    const cacheKey = crypto
-      .createHash('sha256')
-      .update(moduleRoot + target)
-      .digest('hex')
-      .substring(0, 16);
-
-    const cachePath = path.join(this.cacheDir, 'natives', `${cacheKey}.node`);
-
-    if (fs.existsSync(cachePath)) {
-      // Check if source has changed
-      const bindingGypPath = path.join(moduleRoot, 'binding.gyp');
-      if (fs.existsSync(bindingGypPath)) {
-        const cacheStats = fs.statSync(cachePath);
-        const sourceStats = fs.statSync(bindingGypPath);
-        
-        if (cacheStats.mtime > sourceStats.mtime) {
-          return cachePath;
-        }
-      }
-    }
-
-    return null;
-  }
-
-  /**
-   * Cache a native module build
-   * @param {string} moduleRoot - Module root path
-   * @param {string} target - Build target
-   * @param {string} builtBinaryPath - Path to built .node file
-   */
-  cacheNativeBuild(moduleRoot, target, builtBinaryPath) {
-    const cacheKey = crypto
-      .createHash('sha256')
-      .update(moduleRoot + target)
-      .digest('hex')
-      .substring(0, 16);
-
-    const cachePath = path.join(this.cacheDir, 'natives', `${cacheKey}.node`);
-
-    fs.copyFileSync(builtBinaryPath, cachePath);
-  }
-
-  /**
-   * Check if cache entry is valid
-   * @param {CacheEntry} cached - Cached entry
-   * @param {string} filePath - Source file path
-   * @returns {Promise<boolean>}
-   */
-  async isValid(cached, filePath) {
-    if (!fs.existsSync(filePath)) {
-      return false;
-    }
-
-    const currentHash = await this.hashFile(filePath);
-    return currentHash === cached.hash;
-  }
-
-  /**
-   * Compute hash of a file
-   * @param {string} filePath - File path
-   * @returns {Promise<string>}
-   */
-  hashFile(filePath) {
-    return new Promise((resolve, reject) => {
-      const hash = crypto.createHash('sha256');
-      const stream = fs.createReadStream(filePath);
-      
-      stream.on('data', chunk => hash.update(chunk));
-      stream.on('end', () => resolve(hash.digest('hex')));
-      stream.on('error', reject);
-    });
-  }
-
-  /**
-   * Clear cache
-   */
-  clear() {
-    if (fs.existsSync(this.cacheDir)) {
-      fs.rmSync(this.cacheDir, { recursive: true, force: true });
-    }
-    this.ensureCacheDir();
-  }
-}
+/**
+ * build-cache.mjs
+ * Build caching system to speed up incremental builds.
+ */
+
+import fs from 'fs';
+import path from 'path';
+import crypto from 'crypto';
+
+/**
+ * @typedef {Object} CacheEntry
+ * @property {string} hash - Content hash of input
+ * @property {number} timestamp - When cached
+ * @property {any} data - Cached data
+ */
+
+export class BuildCache {
+  /**
+   * @param {string} cacheDir - Cache directory path
+   */
+  constructor(cacheDir = '.seabox-cache') {
+    this.cacheDir = cacheDir;
+    this.ensureCacheDir();
+  }
+
+  /**
+   * Ensure cache directory exists
+   */
+  ensureCacheDir() {
+    if (!fs.existsSync(this.cacheDir)) {
+      fs.mkdirSync(this.cacheDir, { recursive: true });
+    }
+
+    // Create subdirectories
+    const subdirs = ['bundles', 'natives', 'blobs'];
+    for (const subdir of subdirs) {
+      const dirPath = path.join(this.cacheDir, subdir);
+      if (!fs.existsSync(dirPath)) {
+        fs.mkdirSync(dirPath, { recursive: true });
+      }
+    }
+  }
+
+  /**
+   * Compute cache key from entry path and config
+   * @param {string} entryPath - Entry file path
+   * @param {Object} config - Build config
+   * @returns {string}
+   */
+  computeCacheKey(entryPath, config) {
+    const configStr = JSON.stringify({
+      bundler: config.bundler,
+      entry: entryPath
+    });
+    
+    return crypto
+      .createHash('sha256')
+      .update(configStr)
+      .digest('hex')
+      .substring(0, 16);
+  }
+
+  /**
+   * Get cached bundle if valid
+   * @param {string} entryPath - Entry file path
+   * @param {Object} config - Build config
+   * @returns {Object|null}
+   */
+  async getCachedBundle(entryPath, config) {
+    const cacheKey = this.computeCacheKey(entryPath, config);
+    const cachePath = path.join(this.cacheDir, 'bundles', `${cacheKey}.json`);
+
+    if (!fs.existsSync(cachePath)) {
+      return null;
+    }
+
+    try {
+      const cached = JSON.parse(fs.readFileSync(cachePath, 'utf8'));
+      
+      // Validate that source files haven't changed
+      if (await this.isValid(cached, entryPath)) {
+        return cached;
+      }
+    } catch (err) {
+      // Invalid cache entry
+    }
+
+    return null;
+  }
+
+  /**
+   * Cache a bundle result
+   * @param {string} entryPath - Entry file path
+   * @param {Object} config - Build config
+   * @param {Object} bundleResult - Bundle result to cache
+   */
+  async cacheBundle(entryPath, config, bundleResult) {
+    const cacheKey = this.computeCacheKey(entryPath, config);
+    const cachePath = path.join(this.cacheDir, 'bundles', `${cacheKey}.json`);
+
+    const cacheEntry = {
+      hash: await this.hashFile(entryPath),
+      timestamp: Date.now(),
+      data: bundleResult
+    };
+
+    fs.writeFileSync(cachePath, JSON.stringify(cacheEntry, null, 2));
+  }
+
+  /**
+   * Get cached native module build
+   * @param {string} moduleRoot - Module root path
+   * @param {string} target - Build target
+   * @returns {string|null} - Path to cached .node file
+   */
+  getCachedNativeBuild(moduleRoot, target) {
+    const cacheKey = crypto
+      .createHash('sha256')
+      .update(moduleRoot + target)
+      .digest('hex')
+      .substring(0, 16);
+
+    const cachePath = path.join(this.cacheDir, 'natives', `${cacheKey}.node`);
+
+    if (fs.existsSync(cachePath)) {
+      // Check if source has changed
+      const bindingGypPath = path.join(moduleRoot, 'binding.gyp');
+      if (fs.existsSync(bindingGypPath)) {
+        const cacheStats = fs.statSync(cachePath);
+        const sourceStats = fs.statSync(bindingGypPath);
+        
+        if (cacheStats.mtime > sourceStats.mtime) {
+          return cachePath;
+        }
+      }
+    }
+
+    return null;
+  }
+
+  /**
+   * Cache a native module build
+   * @param {string} moduleRoot - Module root path
+   * @param {string} target - Build target
+   * @param {string} builtBinaryPath - Path to built .node file
+   */
+  cacheNativeBuild(moduleRoot, target, builtBinaryPath) {
+    const cacheKey = crypto
+      .createHash('sha256')
+      .update(moduleRoot + target)
+      .digest('hex')
+      .substring(0, 16);
+
+    const cachePath = path.join(this.cacheDir, 'natives', `${cacheKey}.node`);
+
+    fs.copyFileSync(builtBinaryPath, cachePath);
+  }
+
+  /**
+   * Check if cache entry is valid
+   * @param {CacheEntry} cached - Cached entry
+   * @param {string} filePath - Source file path
+   * @returns {Promise<boolean>}
+   */
+  async isValid(cached, filePath) {
+    if (!fs.existsSync(filePath)) {
+      return false;
+    }
+
+    const currentHash = await this.hashFile(filePath);
+    return currentHash === cached.hash;
+  }
+
+  /**
+   * Compute hash of a file
+   * @param {string} filePath - File path
+   * @returns {Promise<string>}
+   */
+  hashFile(filePath) {
+    return new Promise((resolve, reject) => {
+      const hash = crypto.createHash('sha256');
+      const stream = fs.createReadStream(filePath);
+      
+      stream.on('data', chunk => hash.update(chunk));
+      stream.on('end', () => resolve(hash.digest('hex')));
+      stream.on('error', reject);
+    });
+  }
+
+  /**
+   * Clear cache
+   */
+  clear() {
+    if (fs.existsSync(this.cacheDir)) {
+      fs.rmSync(this.cacheDir, { recursive: true, force: true });
+    }
+    this.ensureCacheDir();
+  }
+}

package/lib/build.mjs

@@ -1,77 +1,77 @@
-/**
- * build.mjs (v2)
- * Main build orchestrator using v2 architecture with multi-target support.
- */
-
-import { loadConfig } from './config.mjs';
-import { MultiTargetBuilder } from './multi-target-builder.mjs';
-import * as diag from './diagnostics.mjs';
-import fs from 'fs';
-
-/**
- * Main build function for v2
- * @param {Object} options - Build options
- * @param {string} [options.configPath] - Path to config file
- * @param {boolean} [options.verbose] - Enable verbose logging
- * @param {boolean} [options.debug] - Keep temporary build files
- * @param {string} [options.projectRoot] - Project root directory
- */
-export async function build(options = {}) {
-  // Support both options object and legacy process.argv parsing
-  let configPath = options.configPath;
-  let verbose = options.verbose;
-  let debug = options.debug;
-  let projectRoot = options.projectRoot || process.cwd();
-  
-  // Fallback to process.argv if called without options
-  if (!options.configPath && !options.verbose && !options.debug) {
-    const args = process.argv.slice(2);
-    configPath = args.includes('--config') ? args[args.indexOf('--config') + 1] : null;
-    verbose = args.includes('--verbose');
-    debug = args.includes('--debug');
-  }
-
-  try {
-    // Load configuration
-    const config = loadConfig(configPath, projectRoot);
-    
-    // Config should exist if we got here (CLI checks first)
-    if (!config) {
-      throw new Error('No configuration found. Run: npx seabox init');
-    }
-    
-    // Override verbose from CLI if specified
-    if (verbose) {
-      config.verbose = true;
-    }
-
-    // Create and run multi-target builder
-    const builder = new MultiTargetBuilder(config, projectRoot);
-    const results = await builder.buildAll();
-
-    // Display results
-    diag.separator();
-    diag.info('Output files:');
-    for (const result of results) {
-      const size = diag.formatSize(fs.statSync(result.path).size);
-      diag.info(`  ${result.target}: ${result.path} (${size})`);
-    }
-    diag.separator();
-
-    return results;
-  } catch (error) {
-    diag.separator();
-    diag.error(`Build failed: ${error.message}`);
-    if (verbose || process.argv.includes('--verbose')) {
-      console.error(error.stack);
-    }
-    throw error;
-  }
-}
-
-// Run if called directly
-if (import.meta.url === `file://${process.argv[1]}`) {
-  build().catch(error => {
-    process.exit(1);
-  });
-}
+/**
+ * build.mjs (v2)
+ * Main build orchestrator using v2 architecture with multi-target support.
+ */
+
+import { loadConfig } from './config.mjs';
+import { MultiTargetBuilder } from './multi-target-builder.mjs';
+import * as diag from './diagnostics.mjs';
+import fs from 'fs';
+
+/**
+ * Main build function for v2
+ * @param {Object} options - Build options
+ * @param {string} [options.configPath] - Path to config file
+ * @param {boolean} [options.verbose] - Enable verbose logging
+ * @param {boolean} [options.debug] - Keep temporary build files
+ * @param {string} [options.projectRoot] - Project root directory
+ */
+export async function build(options = {}) {
+  // Support both options object and legacy process.argv parsing
+  let configPath = options.configPath;
+  let verbose = options.verbose;
+  let debug = options.debug;
+  let projectRoot = options.projectRoot || process.cwd();
+  
+  // Fallback to process.argv if called without options
+  if (!options.configPath && !options.verbose && !options.debug) {
+    const args = process.argv.slice(2);
+    configPath = args.includes('--config') ? args[args.indexOf('--config') + 1] : null;
+    verbose = args.includes('--verbose');
+    debug = args.includes('--debug');
+  }
+
+  try {
+    // Load configuration
+    const config = loadConfig(configPath, projectRoot);
+    
+    // Config should exist if we got here (CLI checks first)
+    if (!config) {
+      throw new Error('No configuration found. Run: npx seabox init');
+    }
+    
+    // Override verbose from CLI if specified
+    if (verbose) {
+      config.verbose = true;
+    }
+
+    // Create and run multi-target builder
+    const builder = new MultiTargetBuilder(config, projectRoot);
+    const results = await builder.buildAll();
+
+    // Display results
+    diag.separator();
+    diag.info('Output files:');
+    for (const result of results) {
+      const size = diag.formatSize(fs.statSync(result.path).size);
+      diag.info(`  ${result.target}: ${result.path} (${size})`);
+    }
+    diag.separator();
+
+    return results;
+  } catch (error) {
+    diag.separator();
+    diag.error(`Build failed: ${error.message}`);
+    if (verbose || process.argv.includes('--verbose')) {
+      console.error(error.stack);
+    }
+    throw error;
+  }
+}
+
+// Run if called directly
+if (import.meta.url === `file://${process.argv[1]}`) {
+  build().catch(error => {
+    process.exit(1);
+  });
+}