@craftpipe/contextpack 1.0.0

package/lib/config.js

@@ -0,0 +1,269 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+
+/**
+ * Default configuration values for ContextPack
+ */
+const DEFAULTS = {
+  include: ['**/*'],
+  exclude: [
+    'node_modules/**',
+    '.git/**',
+    'dist/**',
+    'build/**',
+    'coverage/**',
+    '.nyc_output/**',
+    '**/*.min.js',
+    '**/*.map',
+  ],
+  output: 'contextpack-output.json',
+  format: 'json',
+  maxFileSummaryLength: 500,
+  includeDependencyMap: true,
+  includeSymbolIndex: true,
+  verbose: false,
+  rootDir: process.cwd(),
+};
+
+/**
+ * Attempt to read and parse a JSON file from disk.
+ * Returns null if the file does not exist or cannot be parsed.
+ *
+ * @param {string} filePath - Absolute path to the JSON file
+ * @returns {object|null} Parsed JSON object or null
+ */
+function readJSONFile(filePath) {
+  try {
+    const raw = fs.readFileSync(filePath, 'utf8');
+    return JSON.parse(raw);
+  } catch (_err) {
+    return null;
+  }
+}
+
+/**
+ * Locate and load the ContextPack configuration from one of the supported
+ * sources, in priority order:
+ *   1. .contextpackrc.json in the given root directory
+ *   2. "contextpack" key inside package.json in the given root directory
+ *
+ * If neither source is found, an empty object is returned so that defaults
+ * can be applied downstream.
+ *
+ * @param {string} [rootDir] - Directory to search for config files.
+ *   Defaults to process.cwd() when not provided or falsy.
+ * @returns {object} Raw configuration object loaded from disk (may be empty)
+ */
+function loadConfig(rootDir) {
+  const searchDir = (rootDir && typeof rootDir === 'string') ? rootDir : process.cwd();
+
+  // 1. Try .contextpackrc.json
+  const rcPath = path.join(searchDir, '.contextpackrc.json');
+  const rcConfig = readJSONFile(rcPath);
+  if (rcConfig !== null && typeof rcConfig === 'object') {
+    return normalizeConfig(rcConfig, searchDir);
+  }
+
+  // 2. Try "contextpack" key in package.json
+  const pkgPath = path.join(searchDir, 'package.json');
+  const pkg = readJSONFile(pkgPath);
+  if (pkg !== null && typeof pkg === 'object' && pkg.contextpack && typeof pkg.contextpack === 'object') {
+    return normalizeConfig(pkg.contextpack, searchDir);
+  }
+
+  // 3. No config found — return defaults
+  return normalizeConfig({}, searchDir);
+}
+
+/**
+ * Deep-merge two plain objects. Values from `override` take precedence over
+ * values from `base`. Arrays are replaced entirely (not concatenated) so that
+ * CLI flags or file config can fully replace default arrays.
+ *
+ * @param {object} base - Base object
+ * @param {object} override - Object whose values override base
+ * @returns {object} New merged object
+ */
+function deepMerge(base, override) {
+  const result = Object.assign({}, base);
+
+  for (const key of Object.keys(override)) {
+    const overrideVal = override[key];
+    const baseVal = result[key];
+
+    if (
+      overrideVal !== null &&
+      typeof overrideVal === 'object' &&
+      !Array.isArray(overrideVal) &&
+      baseVal !== null &&
+      typeof baseVal === 'object' &&
+      !Array.isArray(baseVal)
+    ) {
+      result[key] = deepMerge(baseVal, overrideVal);
+    } else {
+      result[key] = overrideVal;
+    }
+  }
+
+  return result;
+}
+
+/**
+ * Apply defaults to a raw config object and coerce values to their expected
+ * types. This ensures the returned config is always fully populated and safe
+ * to use without further null-checks by callers.
+ *
+ * @param {object} raw - Raw config object (may be partial or empty)
+ * @param {string} [rootDir] - Root directory to embed in the config
+ * @returns {object} Normalized config object with all defaults applied
+ */
+function normalizeConfig(raw, rootDir) {
+  const src = (raw !== null && typeof raw === 'object') ? raw : {};
+  const merged = deepMerge(DEFAULTS, src);
+
+  // Ensure rootDir is always set
+  if (rootDir && typeof rootDir === 'string') {
+    merged.rootDir = rootDir;
+  }
+  if (!merged.rootDir || typeof merged.rootDir !== 'string') {
+    merged.rootDir = process.cwd();
+  }
+
+  // Coerce arrays
+  if (!Array.isArray(merged.include)) {
+    merged.include = DEFAULTS.include.slice();
+  }
+  if (!Array.isArray(merged.exclude)) {
+    merged.exclude = DEFAULTS.exclude.slice();
+  }
+
+  // Coerce strings
+  if (typeof merged.output !== 'string' || !merged.output) {
+    merged.output = DEFAULTS.output;
+  }
+  if (typeof merged.format !== 'string' || !merged.format) {
+    merged.format = DEFAULTS.format;
+  }
+
+  // Normalise format to lowercase
+  merged.format = merged.format.toLowerCase();
+  if (!['json', 'markdown', 'md'].includes(merged.format)) {
+    merged.format = DEFAULTS.format;
+  }
+  // Normalise 'md' alias
+  if (merged.format === 'md') {
+    merged.format = 'markdown';
+  }
+
+  // Coerce numbers
+  const maxLen = parseInt(merged.maxFileSummaryLength, 10);
+  merged.maxFileSummaryLength = isNaN(maxLen) || maxLen < 0 ? DEFAULTS.maxFileSummaryLength : maxLen;
+
+  // Coerce booleans
+  merged.includeDependencyMap = Boolean(merged.includeDependencyMap);
+  merged.includeSymbolIndex = Boolean(merged.includeSymbolIndex);
+  merged.verbose = Boolean(merged.verbose);
+
+  return merged;
+}
+
+/**
+ * Merge a file-based (or default) config object with CLI flags. CLI flags
+ * take the highest precedence. Only flags that are explicitly provided
+ * (i.e. not undefined) are applied so that absent CLI flags do not
+ * accidentally overwrite file-based config values.
+ *
+ * Recognised flag keys and their mappings:
+ *   flags.include          → config.include   (array or comma-separated string)
+ *   flags.exclude          → config.exclude   (array or comma-separated string)
+ *   flags.output           → config.output
+ *   flags.format           → config.format
+ *   flags.maxFileSummaryLength → config.maxFileSummaryLength
+ *   flags.includeDependencyMap → config.includeDependencyMap
+ *   flags.includeSymbolIndex   → config.includeSymbolIndex
+ *   flags.verbose          → config.verbose
+ *   flags.rootDir          → config.rootDir
+ *
+ * @param {object} fileConfig - Config object produced by loadConfig()
+ * @param {object} [flags] - CLI flag object (e.g. from minimist or yargs).
+ *   May be null or undefined — treated as an empty object in that case.
+ * @returns {object} New normalized config object with CLI flags applied
+ */
+function mergeWithFlags(fileConfig, flags) {
+  const base = (fileConfig !== null && typeof fileConfig === 'object') ? fileConfig : {};
+  const cliFlags = (flags !== null && typeof flags === 'object') ? flags : {};
+
+  const overrides = {};
+
+  // --include
+  if (cliFlags.include !== undefined) {
+    overrides.include = normalizeArrayFlag(cliFlags.include);
+  }
+
+  // --exclude
+  if (cliFlags.exclude !== undefined) {
+    overrides.exclude = normalizeArrayFlag(cliFlags.exclude);
+  }
+
+  // --output / -o
+  if (cliFlags.output !== undefined && cliFlags.output !== null) {
+    overrides.output = String(cliFlags.output);
+  }
+
+  // --format / -f
+  if (cliFlags.format !== undefined && cliFlags.format !== null) {
+    overrides.format = String(cliFlags.format);
+  }
+
+  // --maxFileSummaryLength
+  if (cliFlags.maxFileSummaryLength !== undefined) {
+    const parsed = parseInt(cliFlags.maxFileSummaryLength, 10);
+    if (!isNaN(parsed) && parsed >= 0) {
+      overrides.maxFileSummaryLength = parsed;
+    }
+  }
+
+  // --includeDependencyMap / --no-includeDependencyMap
+  if (cliFlags.includeDependencyMap !== undefined) {
+    overrides.includeDependencyMap = Boolean(cliFlags.includeDependencyMap);
+  }
+
+  // --includeSymbolIndex / --no-includeSymbolIndex
+  if (cliFlags.includeSymbolIndex !== undefined) {
+    overrides.includeSymbolIndex = Boolean(cliFlags.includeSymbolIndex);
+  }
+
+  // --verbose / -v
+  if (cliFlags.verbose !== undefined) {
+    overrides.verbose = Boolean(cliFlags.verbose);
+  }
+
+  // --rootDir
+  if (cliFlags.rootDir !== undefined && cliFlags.rootDir !== null && typeof cliFlags.rootDir === 'string' && cliFlags.rootDir.trim() !== '') {
+    overrides.rootDir = cliFlags.rootDir.trim();
+  }
+
+  const merged = deepMerge(base, overrides);
+  return normalizeConfig(merged, merged.rootDir || base.rootDir);
+}
+
+/**
+ * Normalise a flag value that should represent an array of strings.
+ * Accepts an existing array, a comma-separated string, or a single string.
+ *
+ * @param {string|string[]} value - Raw flag value
+ * @returns {string[]} Array of trimmed, non-empty strings
+ */
+function normalizeArrayFlag(value) {
+  if (Array.isArray(value)) {
+    return value.map(String).map(function (s) { return s.trim(); }).filter(Boolean);
+  }
+  if (typeof value === 'string') {
+    return value.split(',').map(function (s) { return s.trim(); }).filter(Boolean);
+  }
+  return [];
+}
+
+module.exports = { loadConfig, mergeWithFlags };

package/lib/license.js

@@ -0,0 +1,180 @@
+'use strict';
+
+/**
+ * lib/license.js
+ * Checks PRO_LICENSE environment variable; returns current license tier (free or pro);
+ * asserts pro license for gated features and shows a formatted upgrade prompt when license is absent.
+ *
+ * Part of the ContextPack product.
+ */
+
+/**
+ * Valid license tiers
+ */
+const TIER_FREE = 'free';
+const TIER_PRO = 'pro';
+
+/**
+ * Upgrade prompt lines shown when a premium feature is requested without a valid license
+ */
+const UPGRADE_PROMPT_LINES = [
+  '',
+  '╔══════════════════════════════════════════════════════════════╗',
+  '║              ContextPack — Upgrade to PRO                   ║',
+  '╠══════════════════════════════════════════════════════════════╣',
+  '║  This feature requires a ContextPack PRO license.           ║',
+  '║                                                              ║',
+  '║  PRO features include:                                       ║',
+  '║    • Watch mode  — auto-regenerate bundles on file change   ║',
+  '║    • HTML report — rich visual dependency & token report    ║',
+  '║    • Enhanced config — per-directory rules & filters        ║',
+  '║                                                              ║',
+  '║  To activate PRO, set the environment variable:             ║',
+  '║    PRO_LICENSE=<your-license-key>                           ║',
+  '║                                                              ║',
+  '║  Get your license at: https://contextpack.dev/pro           ║',
+  '╚══════════════════════════════════════════════════════════════╝',
+  '',
+];
+
+/**
+ * Determine whether the supplied license key string is considered valid.
+ * A key is valid when it is a non-empty string after trimming whitespace.
+ *
+ * @param {*} key - Raw value of the PRO_LICENSE environment variable
+ * @returns {boolean} True when the key is a non-empty string
+ */
+function isValidKey(key) {
+  return typeof key === 'string' && key.trim().length > 0;
+}
+
+/**
+ * Returns the current license status based on the PRO_LICENSE environment variable.
+ *
+ * @returns {{ tier: string, isProLicensed: boolean, licenseKey: string|null }}
+ *   An object describing the current license state:
+ *   - tier: 'pro' when a valid PRO_LICENSE is present, otherwise 'free'
+ *   - isProLicensed: boolean shorthand for tier === 'pro'
+ *   - licenseKey: the trimmed license key string, or null when absent/invalid
+ */
+function getLicenseStatus() {
+  const raw = process.env.PRO_LICENSE;
+
+  if (isValidKey(raw)) {
+    return {
+      tier: TIER_PRO,
+      isProLicensed: true,
+      licenseKey: raw.trim(),
+    };
+  }
+
+  return {
+    tier: TIER_FREE,
+    isProLicensed: false,
+    licenseKey: null,
+  };
+}
+
+/**
+ * Builds and returns the formatted upgrade prompt string.
+ * The prompt is also printed to stderr so it is visible in terminal output
+ * without polluting stdout (which may carry JSON or Markdown bundle output).
+ *
+ * @param {object} [options] - Optional display options
+ * @param {string} [options.featureName] - Name of the premium feature that was requested;
+ *   when provided it is included in the prompt header for context.
+ * @param {boolean} [options.printToStderr=true] - When true (default) the prompt is
+ *   written to process.stderr in addition to being returned as a string.
+ * @returns {string} The formatted upgrade prompt text
+ */
+function showUpgradePrompt(options) {
+  const opts = options || {};
+  const featureName = (typeof opts.featureName === 'string' && opts.featureName.trim().length > 0)
+    ? opts.featureName.trim()
+    : null;
+  const printToStderr = opts.printToStderr !== false;
+
+  const lines = UPGRADE_PROMPT_LINES.slice();
+
+  if (featureName) {
+    // Insert a feature-specific line after the first separator
+    const insertIndex = 4;
+    lines.splice(insertIndex, 0, '║  Requested feature: ' + padRight(featureName, 41) + '║');
+  }
+
+  const prompt = lines.join('\n');
+
+  if (printToStderr) {
+    try {
+      process.stderr.write(prompt + '\n');
+    } catch (_err) {
+      // Silently ignore write errors (e.g. in test environments with closed stderr)
+    }
+  }
+
+  return prompt;
+}
+
+/**
+ * Asserts that a valid PRO_LICENSE is present in the environment.
+ * When the license is absent or invalid, displays the upgrade prompt and
+ * throws an Error so that callers can handle the gate gracefully.
+ *
+ * @param {object} [options] - Optional options forwarded to showUpgradePrompt
+ * @param {string} [options.featureName] - Name of the premium feature being gated
+ * @param {boolean} [options.printToStderr=true] - Whether to print the prompt to stderr
+ * @throws {Error} When no valid PRO_LICENSE is found
+ * @returns {void} Returns normally when a valid license is present
+ */
+function assertProLicense(options) {
+  const opts = options || {};
+  const status = getLicenseStatus();
+
+  if (status.isProLicensed) {
+    return;
+  }
+
+  showUpgradePrompt(opts);
+
+  const featureName = (typeof opts.featureName === 'string' && opts.featureName.trim().length > 0)
+    ? opts.featureName.trim()
+    : 'this feature';
+
+  throw new Error(
+    'ContextPack PRO license required to use ' + featureName + '. ' +
+    'Set the PRO_LICENSE environment variable to your license key. ' +
+    'Visit https://contextpack.dev/pro to obtain a license.'
+  );
+}
+
+// ---------------------------------------------------------------------------
+// Internal helpers
+// ---------------------------------------------------------------------------
+
+/**
+ * Right-pads a string with spaces to the given total length.
+ * Truncates with an ellipsis if the string exceeds the target length.
+ *
+ * @param {string} str - The string to pad
+ * @param {number} length - Desired total length
+ * @returns {string} Padded (or truncated) string
+ */
+function padRight(str, length) {
+  if (typeof str !== 'string') {
+    str = String(str);
+  }
+  if (str.length > length) {
+    return str.slice(0, length - 1) + '…';
+  }
+  return str + ' '.repeat(length - str.length);
+}
+
+// ---------------------------------------------------------------------------
+// Exports
+// ---------------------------------------------------------------------------
+
+module.exports = {
+  getLicenseStatus,
+  assertProLicense,
+  showUpgradePrompt,
+};