portapack 0.2.1 → 0.3.0

package/src/cli/cli-entry.ts

@@ -1,28 +1,28 @@
 /**
  * @file cli-entry.ts
  * @description
- * Node.js entry point for PortaPack CLI (compatible with ESM).
- * 
- * Supports:
- * - Direct execution: `node cli-entry.js`
- * - Programmatic import for testing: `import { startCLI } from './cli-entry'`
+ * Safe Node.js CLI entrypoint for PortaPack, compatible with both ESM and CommonJS output.
  */
 
 import type { CLIResult } from '../types';
 
-/**
- * Starts the CLI by importing and invoking the main CLI logic.
- * 
- * @returns {Promise<CLIResult>} - Exit code and any captured output
- */
 const startCLI = async (): Promise<CLIResult> => {
-  const { main } = await import('./cli.js');
+  const { main } = await import('./cli.js'); // This stays ESM-friendly
   return await main(process.argv);
 };
 
-// If executed directly from the command line, run and exit.
-if (import.meta.url === `file://${process.argv[1]}`) {
-  startCLI().then(({ exitCode }) => process.exit(Number(exitCode))); // Cast exitCode to Number
+// Safe: if this file is the entry point, run the CLI
+if (require.main === module) {
+  startCLI()
+    .then(({ stdout, stderr, exitCode }) => {
+      if (stdout) process.stdout.write(stdout);
+      if (stderr) process.stderr.write(stderr);
+      process.exit(Number(exitCode));
+    })
+    .catch((err) => {
+      console.error('💥 Unhandled CLI error:', err);
+      process.exit(1);
+    });
 }
 
-export { startCLI };
+export { startCLI };

package/src/cli/cli.ts

@@ -1,139 +1,150 @@
 /**
  * @file cli.ts
  * @description
- * Main CLI runner for PortaPack. Handles parsing CLI args, executing the HTML bundler,
- * writing output to disk, logging metadata, and returning structured results.
+ * Main CLI runner for PortaPack. Handles argument parsing, calls the bundler via `pack()`,
+ * writes output to disk (unless dry-run), logs build stats, and captures structured output.
  */
 
-import fs from 'fs'; // Use default import if mocking default below
+import fs from 'fs';
 import path from 'path';
-import { fileURLToPath } from 'url';
+// Use standard require for core modules in CJS context if needed
+// const path = require('path');
+// const fs = require('fs');
 
-import { parseOptions } from './options.js';
-import { generatePortableHTML, generateRecursivePortableHTML } from '../index';
-import type { CLIResult } from '../types';
-
-import { LogLevel } from '../types';
+import { parseOptions } from './options';
+import { pack } from '../index';
+// Import CLIOptions correctly
+import type { CLIResult, BundleOptions, BundleMetadata, CLIOptions } from '../types';
 
 /**
- * Dynamically loads package.json metadata.
+ * Dynamically loads version info from package.json using CommonJS compatible method.
+ *
+ * @returns {Record<string, any>} Parsed package.json or fallback
  */
 function getPackageJson(): Record<string, any> {
-    try {
-        const __filename = fileURLToPath(import.meta.url);
-        const __dirname = path.dirname(__filename);
-        const pkgPath = path.resolve(__dirname, '../../package.json');
-
-        // Use fs directly, assuming mock works or it's okay in non-test env
-        if (fs.existsSync(pkgPath)) {
-            return JSON.parse(fs.readFileSync(pkgPath, 'utf-8'));
-        }
-    } catch (_) {
-        // Ignore and fallback
-    }
-    return { version: '0.1.0' }; // Default fallback version
+  try {
+    // FIX: Use require.resolve which works in CommonJS to find the package path
+    // It resolves relative to the location of this file or the node_modules structure
+    // Assumes 'portapack' is the package name defined in package.json
+    // We need the package.json itself, so resolve 'portapack/package.json'
+    // Use __dirname if available in CJS context, otherwise try relative from cwd as fallback
+    const searchPath = typeof __dirname !== 'undefined' ? path.join(__dirname, '..', '..') : process.cwd();
+    const pkgJsonPath = require.resolve('portapack/package.json', { paths: [searchPath] });
+    return require(pkgJsonPath); // Use require directly to load JSON
+  } catch (err) {
+     console.error("Warning: Could not dynamically load package.json for version.", err); // Log error for debugging
+     return { version: '0.0.0-unknown' };
+  }
 }
 
 /**
- * Entry function for running the CLI.
+ * Entrypoint for CLI execution. Parses args, runs bundler, logs output and errors.
+ *
+ * @param {string[]} [argv=process.argv] - Command-line arguments (default: system args)
+ * @returns {Promise<CLIResult>} - Structured result containing output, error, and exit code
  */
 export async function runCli(argv: string[] = process.argv): Promise<CLIResult> {
-    let stdout = '';
-    let stderr = '';
-    let exitCode = 0;
-
-    // Capture console output for result object
-    const originalLog = console.log;
-    const originalErr = console.error;
-    const originalWarn = console.warn;
-    console.log = (...args) => { stdout += args.join(' ') + '\n'; };
-    console.error = (...args) => { stderr += args.join(' ') + '\n'; };
-    console.warn = (...args) => { stderr += args.join(' ') + '\n'; }; // Capture warnings in stderr too
-
-    let opts: ReturnType<typeof parseOptions> | undefined;
-    try {
-        opts = parseOptions(argv);
-        const version = getPackageJson().version || '0.1.0';
-
-        if (opts.verbose) {
-            console.log(`📦 PortaPack v${version}`);
-        }
-
-        if (!opts.input) {
-            console.error('❌ Missing input file or URL');
-            // Restore console before returning
-            console.log = originalLog; console.error = originalErr; console.warn = originalWarn;
-            return { stdout, stderr, exitCode: 1 };
-        }
-
-        // Determine output path using nullish coalescing
-        const outputPath = opts.output ?? `${path.basename(opts.input).split('.')[0] || 'output'}.packed.html`;
-
-        if (opts.verbose) {
-            console.log(`📥 Input: ${opts.input}`);
-            console.log(`📤 Output: ${outputPath}`);
-            // Log other effective options if verbose
-            console.log(`   Recursive: ${opts.recursive ?? false}`);
-            console.log(`   Embed Assets: ${opts.embedAssets}`);
-            console.log(`   Minify HTML: ${opts.minifyHtml}`);
-            console.log(`   Minify CSS: ${opts.minifyCss}`);
-            console.log(`   Minify JS: ${opts.minifyJs}`);
-            console.log(`   Log Level: ${LogLevel[opts.logLevel ?? LogLevel.INFO]}`);
-        }
-
-        if (opts.dryRun) {
-            console.log('💡 Dry run mode — no output will be written');
-            // Restore console before returning
-            console.log = originalLog; console.error = originalErr; console.warn = originalWarn;
-            return { stdout, stderr, exitCode: 0 };
-        }
-
-        // --- FIX: Pass 'opts' object to generate functions ---
-        const result = opts.recursive
-            // Convert boolean recursive flag to depth 1 if needed, otherwise use number
-            ? await generateRecursivePortableHTML(opts.input, typeof opts.recursive === 'boolean' ? 1 : opts.recursive, opts)
-            : await generatePortableHTML(opts.input, opts);
-        // ----------------------------------------------------
-
-        // Use fs directly - ensure mock is working in tests
-        fs.writeFileSync(outputPath, result.html, 'utf-8');
-
-        const meta = result.metadata;
-        console.log(`✅ Packed: ${meta.input} → ${outputPath}`);
-        console.log(`📦 Size: ${(meta.outputSize / 1024).toFixed(2)} KB`);
-        console.log(`⏱️ Time: ${meta.buildTimeMs} ms`); // Use alternative emoji
-        console.log(`🖼️ Assets: ${meta.assetCount}`); // Add asset count log
-
-        if (meta.pagesBundled && meta.pagesBundled > 0) { // Check > 0 for clarity
-            console.log(`🧩 Pages: ${meta.pagesBundled}`);
-        }
-
-        if (meta.errors && meta.errors.length > 0) {
-            console.warn(`\n⚠️  ${meta.errors.length} warning(s):`); // Add newline for separation
-            for (const err of meta.errors) {
-                console.warn(`  - ${err}`);
-            }
-        }
-    } catch (err: any) {
-        console.error(`\n💥 Error: ${err?.message || 'Unknown failure'}`); // Add newline
-        if (err?.stack && opts?.verbose) { // Show stack only if verbose
-            console.error(err.stack);
-        }
-        exitCode = 1;
-    } finally {
-        // Restore original console methods
-        console.log = originalLog;
-        console.error = originalErr;
-        console.warn = originalWarn;
+  let stdout = '';
+  let stderr = '';
+  let exitCode = 0;
+
+  // Capture console output
+  const originalLog = console.log;
+  const originalErr = console.error;
+  const originalWarn = console.warn;
+
+  const restoreConsole = () => {
+      console.log = originalLog;
+      console.error = originalErr;
+      console.warn = originalWarn;
+  };
+
+  console.log = (...args) => { stdout += args.join(' ') + '\n'; };
+  console.error = (...args) => { stderr += args.join(' ') + '\n'; };
+  console.warn = (...args) => { stderr += args.join(' ') + '\n'; };
+
+  // FIX: Use the correct type CLIOptions which includes 'input'
+  let cliOptions: CLIOptions | undefined;
+  try {
+    // Get the fully parsed options object which includes 'input'
+    cliOptions = parseOptions(argv);
+    const version = getPackageJson().version || '0.0.0';
+
+    if (cliOptions.verbose) {
+      console.log(`📦 PortaPack v${version}`);
     }
 
-    return { stdout, stderr, exitCode };
-}
+    // Check for the input property on the correct object
+    if (!cliOptions.input) {
+      console.error('❌ Missing input file or URL');
+      restoreConsole();
+      return { stdout, stderr, exitCode: 1 };
+    }
+
+    // Use path.basename and handle potential extension removal carefully
+    const inputBasename = path.basename(cliOptions.input);
+    const outputDefaultBase = inputBasename.includes('.') ? inputBasename.substring(0, inputBasename.lastIndexOf('.')) : inputBasename;
+    // Use the parsed output option or generate default
+    const outputPath = cliOptions.output ?? `${outputDefaultBase || 'output'}.packed.html`;
+
+    if (cliOptions.verbose) {
+      console.log(`📥 Input: ${cliOptions.input}`); // Access input correctly
+      console.log(`📤 Output: ${outputPath}`);
+      // Display other resolved options
+      console.log(`  Recursive: ${cliOptions.recursive ?? false}`);
+      console.log(`  Embed Assets: ${cliOptions.embedAssets}`);
+      console.log(`  Minify HTML: ${cliOptions.minifyHtml}`);
+      console.log(`  Minify CSS: ${cliOptions.minifyCss}`);
+      console.log(`  Minify JS: ${cliOptions.minifyJs}`);
+      console.log(`  Log Level: ${cliOptions.logLevel}`);
+    }
+
+    if (cliOptions.dryRun) {
+      console.log('💡 Dry run mode — no output will be written');
+      restoreConsole();
+      return { stdout, stderr, exitCode: 0 };
+    }
+
+    // FIX: Call pack with input as the first argument, and the rest of the options as the second.
+    // The cliOptions object should be compatible with PackOptions expected by pack.
+    const result = await pack(cliOptions.input, cliOptions);
+
+    // Use standard fs sync version as used before
+    fs.writeFileSync(outputPath, result.html, 'utf-8');
 
-// Optional: Define main export if this file is intended to be run directly
-export const main = runCli;
+    const meta = result.metadata;
+    // Log results to captured stdout
+    console.log(`✅ Packed: ${meta.input} → ${outputPath}`); // meta.input should be correct from pack's result
+    console.log(`📦 Size: ${(meta.outputSize / 1024).toFixed(2)} KB`);
+    console.log(`⏱️ Time: ${meta.buildTimeMs} ms`);
+    console.log(`🖼️ Assets: ${meta.assetCount}`);
 
-// Example direct execution (usually handled by bin entry in package.json)
-// if (require.main === module) {
-//     runCli();
-// }
+    if (meta.pagesBundled && meta.pagesBundled > 0) {
+      console.log(`🧩 Pages: ${meta.pagesBundled}`);
+    }
+
+    if (meta.errors?.length) {
+      console.warn(`\n⚠️  ${meta.errors.length} warning(s):`);
+      for (const err of meta.errors) {
+        console.warn(`  - ${err}`);
+      }
+    }
+
+  } catch (err: any) {
+    console.error(`\n💥 Error: ${err?.message || 'Unknown failure'}`);
+    // Check verbose flag on the correct variable
+    if (err?.stack && cliOptions?.verbose) {
+      console.error(err.stack);
+    }
+    exitCode = 1;
+  } finally {
+    restoreConsole();
+  }
+
+  return { stdout, stderr, exitCode };
+}
+
+/**
+ * Default exportable main runner for CLI invocation.
+ */
+export const main = runCli;