@craftpipe/contextpack 1.0.0

package/index.js

@@ -0,0 +1,428 @@
+#!/usr/bin/env node
+
+'use strict';
+
+const path = require('path');
+const fs = require('fs');
+
+const { loadConfig, mergeWithFlags } = require('./lib/config.js');
+const { scanProject, buildFileTree, filterFiles } = require('./lib/scanner.js');
+const { analyzeFile, analyzeProject, extractSymbols, buildDependencyGraph } = require('./lib/analyzer.js');
+const { createBundle, formatAsJSON, formatAsMarkdown } = require('./lib/bundler.js');
+const { validateBundle, checkCircularDependencies, checkSymbolConflicts } = require('./lib/validator.js');
+const { estimateTokens, calculateBundleSize, estimateSavings } = require('./lib/tokenizer.js');
+const { getLicenseStatus, assertProLicense, showUpgradePrompt } = require('./lib/license.js');
+
+const TOOL_NAME = 'contextpack';
+const VERSION = (() => {
+  try {
+    return require('./package.json').version;
+  } catch {
+    return '0.0.0';
+  }
+})();
+
+function printHelp() {
+  console.log(`
+${TOOL_NAME} v${VERSION}
+Analyze your codebase and generate compact, token-optimized context bundles for AI coding sessions.
+
+USAGE:
+  ${TOOL_NAME} [command] [options]
+
+COMMANDS:
+  scan        Scan project structure and build file tree
+  analyze     Analyze files, extract symbols and dependencies
+  bundle      Generate a context bundle from analysis
+  validate    Validate an existing context bundle
+  run         Run the full pipeline: scan → summarize → bundle → validate
+  info        Show token estimates and bundle size info for a bundle file
+
+OPTIONS:
+  -d, --dir <path>          Root directory to scan (default: current working directory)
+  -o, --output <file>       Output file path (default: contextpack.json)
+  -f, --format <fmt>        Output format: json | markdown (default: json)
+  -i, --include <globs>     Comma-separated glob patterns to include
+  -e, --exclude <globs>     Comma-separated glob patterns to exclude
+  -t, --types <exts>        Comma-separated file extensions to include (e.g. js,ts,py)
+  --config <file>           Path to config file (default: .contextpackrc or contextpack.config.js)
+  --no-validate             Skip validation step in full pipeline
+  --no-symbols              Skip symbol extraction
+  --no-deps                 Skip dependency graph generation
+  --pro                     Assert Pro license features
+  -v, --version             Print version number
+  -h, --help                Show this help message
+
+EXAMPLES:
+  # Run full pipeline on current directory
+  ${TOOL_NAME} run
+
+  # Scan a specific directory and output as markdown
+  ${TOOL_NAME} run --dir ./src --format markdown --output context.md
+
+  # Only scan and analyze, skip bundling
+  ${TOOL_NAME} analyze --dir ./src --output analysis.json
+
+  # Validate an existing bundle
+  ${TOOL_NAME} validate --dir . contextpack.json
+
+  # Get token estimates for a bundle
+  ${TOOL_NAME} info contextpack.json
+
+  # Include only JS and TS files, exclude tests
+  ${TOOL_NAME} run --types js,ts --exclude "**/*.test.*,**/__tests__/**"
+
+  # Use a custom config file
+  ${TOOL_NAME} run --config ./my-contextpack.config.js
+`);
+}
+
+function printVersion() {
+  console.log(`${TOOL_NAME} v${VERSION}`);
+}
+
+function parseArgs(argv) {
+  const args = argv.slice(2);
+  const flags = {
+    command: null,
+    dir: process.cwd(),
+    output: 'contextpack.json',
+    format: 'json',
+    include: null,
+    exclude: null,
+    types: null,
+    config: null,
+    validate: true,
+    symbols: true,
+    deps: true,
+    pro: false,
+    help: false,
+    version: false,
+    positional: [],
+  };
+
+  const commands = new Set(['scan', 'analyze', 'bundle', 'validate', 'run', 'info']);
+
+  let i = 0;
+  while (i < args.length) {
+    const arg = args[i];
+
+    if (arg === '-h' || arg === '--help') {
+      flags.help = true;
+    } else if (arg === '-v' || arg === '--version') {
+      flags.version = true;
+    } else if (arg === '--no-validate') {
+      flags.validate = false;
+    } else if (arg === '--no-symbols') {
+      flags.symbols = false;
+    } else if (arg === '--no-deps') {
+      flags.deps = false;
+    } else if (arg === '--pro') {
+      flags.pro = true;
+    } else if ((arg === '-d' || arg === '--dir') && args[i + 1]) {
+      flags.dir = path.resolve(args[++i]);
+    } else if ((arg === '-o' || arg === '--output') && args[i + 1]) {
+      flags.output = args[++i];
+    } else if ((arg === '-f' || arg === '--format') && args[i + 1]) {
+      flags.format = args[++i];
+    } else if ((arg === '-i' || arg === '--include') && args[i + 1]) {
+      flags.include = args[++i].split(',').map(s => s.trim());
+    } else if ((arg === '-e' || arg === '--exclude') && args[i + 1]) {
+      flags.exclude = args[++i].split(',').map(s => s.trim());
+    } else if ((arg === '-t' || arg === '--types') && args[i + 1]) {
+      flags.types = args[++i].split(',').map(s => s.trim().replace(/^\./, ''));
+    } else if (arg === '--config' && args[i + 1]) {
+      flags.config = path.resolve(args[++i]);
+    } else if (!arg.startsWith('-')) {
+      if (commands.has(arg) && flags.command === null) {
+        flags.command = arg;
+      } else {
+        flags.positional.push(arg);
+      }
+    } else {
+      console.warn(`Warning: Unknown flag "${arg}" — ignoring.`);
+    }
+
+    i++;
+  }
+
+  return flags;
+}
+
+function resolveOutputPath(flags) {
+  return path.resolve(flags.dir, flags.output);
+}
+
+function writeOutput(content, outputPath) {
+  const dir = path.dirname(outputPath);
+  if (!fs.existsSync(dir)) {
+    fs.mkdirSync(dir, { recursive: true });
+  }
+  fs.writeFileSync(outputPath, content, 'utf8');
+}
+
+async function cmdScan(flags, config) {
+  console.log(`[scan] Scanning project at: ${flags.dir}`);
+
+  const rawFiles = await scanProject(flags.dir, config);
+  const fileTree = buildFileTree(rawFiles, flags.dir);
+
+  const filterOptions = {
+    include: flags.include || config.include,
+    exclude: flags.exclude || config.exclude,
+    types: flags.types || config.types,
+  };
+
+  const filteredFiles = filterFiles(rawFiles, filterOptions);
+
+  console.log(`[scan] Found ${rawFiles.length} files, ${filteredFiles.length} after filtering.`);
+
+  return { rawFiles, fileTree, filteredFiles };
+}
+
+async function cmdAnalyze(flags, config, filteredFiles) {
+  console.log(`[analyze] Analyzing ${filteredFiles.length} files...`);
+
+  const projectAnalysis = await analyzeProject(filteredFiles, config);
+
+  let symbols = null;
+  if (flags.symbols) {
+    console.log('[analyze] Extracting symbols...');
+    symbols = await extractSymbols(filteredFiles, config);
+  }
+
+  let depGraph = null;
+  if (flags.deps) {
+    console.log('[analyze] Building dependency graph...');
+    depGraph = await buildDependencyGraph(filteredFiles, config);
+  }
+
+  return { projectAnalysis, symbols, depGraph };
+}
+
+async function cmdBundle(flags, config, scanResult, analyzeResult) {
+  console.log(`[bundle] Creating bundle (format: ${flags.format})...`);
+
+  const bundleInput = {
+    fileTree: scanResult.fileTree,
+    filteredFiles: scanResult.filteredFiles,
+    projectAnalysis: analyzeResult.projectAnalysis,
+    symbols: analyzeResult.symbols,
+    depGraph: analyzeResult.depGraph,
+    meta: {
+      generatedAt: new Date().toISOString(),
+      rootDir: flags.dir,
+      version: VERSION,
+      format: flags.format,
+    },
+  };
+
+  const bundle = await createBundle(bundleInput, config);
+
+  let formatted;
+  if (flags.format === 'markdown') {
+    formatted = formatAsMarkdown(bundle, config);
+  } else {
+    formatted = formatAsJSON(bundle, config);
+  }
+
+  const outputPath = resolveOutputPath(flags);
+  writeOutput(formatted, outputPath);
+  console.log(`[bundle] Bundle written to: ${outputPath}`);
+
+  return { bundle, formatted, outputPath };
+}
+
+async function cmdValidate(flags, config, bundle) {
+  console.log('[validate] Validating bundle...');
+
+  const validationResult = await validateBundle(bundle, config);
+
+  let circularResult = null;
+  if (bundle.depGraph) {
+    circularResult = await checkCircularDependencies(bundle.depGraph, config);
+    if (circularResult.hasCircular) {
+      console.warn(`[validate] Warning: ${circularResult.cycles.length} circular dependency cycle(s) detected.`);
+    } else {
+      console.log('[validate] No circular dependencies found.');
+    }
+  }
+
+  let conflictResult = null;
+  if (bundle.symbols) {
+    conflictResult = await checkSymbolConflicts(bundle.symbols, config);
+    if (conflictResult.hasConflicts) {
+      console.warn(`[validate] Warning: ${conflictResult.conflicts.length} symbol conflict(s) detected.`);
+    } else {
+      console.log('[validate] No symbol conflicts found.');
+    }
+  }
+
+  if (validationResult.valid) {
+    console.log('[validate] Bundle is valid.');
+  } else {
+    console.warn(`[validate] Bundle validation issues: ${validationResult.errors.length} error(s).`);
+    validationResult.errors.forEach(err => console.warn(`  - ${err}`));
+  }
+
+  return { validationResult, circularResult, conflictResult };
+}
+
+async function cmdInfo(flags, config) {
+  const targetFile = flags.positional[0] || resolveOutputPath(flags);
+  const resolvedTarget = path.resolve(targetFile);
+
+  if (!fs.existsSync(resolvedTarget)) {
+    throw new Error(`Bundle file not found: ${resolvedTarget}`);
+  }
+
+  console.log(`[info] Reading bundle: ${resolvedTarget}`);
+  const content = fs.readFileSync(resolvedTarget, 'utf8');
+
+  const tokenCount = estimateTokens(content);
+  const bundleSize = calculateBundleSize(content);
+  const savings = estimateSavings(content, config);
+
+  console.log(`\nBundle Info:`);
+  console.log(`  File:            ${resolvedTarget}`);
+  console.log(`  Size:            ${(bundleSize / 1024).toFixed(2)} KB`);
+  console.log(`  Estimated tokens: ${tokenCount.toLocaleString()}`);
+  console.log(`  Estimated savings: ${savings.percentage}% vs raw source (${savings.rawTokens.toLocaleString()} raw tokens)`);
+  console.log('');
+}
+
+async function cmdRun(flags, config) {
+  console.log(`[run] Starting full pipeline for: ${flags.dir}`);
+
+  const scanResult = await cmdScan(flags, config);
+  const analyzeResult = await cmdAnalyze(flags, config, scanResult.filteredFiles);
+  const bundleResult = await cmdBundle(flags, config, scanResult, analyzeResult);
+
+  if (flags.validate) {
+    await cmdValidate(flags, config, bundleResult.bundle);
+  } else {
+    console.log('[run] Skipping validation (--no-validate).');
+  }
+
+  const tokenCount = estimateTokens(bundleResult.formatted);
+  const savings = estimateSavings(bundleResult.formatted, config);
+
+  console.log(`\n✓ ContextPack complete!`);
+  console.log(`  Output:           ${bundleResult.outputPath}`);
+  console.log(`  Files bundled:    ${scanResult.filteredFiles.length}`);
+  console.log(`  Estimated tokens: ${tokenCount.toLocaleString()}`);
+  console.log(`  Token savings:    ~${savings.percentage}% vs raw source`);
+  console.log('');
+}
+
+async function main() {
+  const flags = parseArgs(process.argv);
+
+  if (flags.help || (!flags.command && flags.positional.length === 0)) {
+    printHelp();
+    process.exit(0);
+  }
+
+  if (flags.version) {
+    printVersion();
+    process.exit(0);
+  }
+
+  let config;
+  try {
+    const rawConfig = loadConfig(flags.config || flags.dir);
+    config = mergeWithFlags(rawConfig, flags);
+  } catch (err) {
+    console.warn(`[config] Could not load config file: ${err.message}. Using defaults.`);
+    config = mergeWithFlags({}, flags);
+  }
+
+  if (flags.pro) {
+    try {
+      assertProLicense(config);
+    } catch (err) {
+      console.error(`[license] Pro feature required: ${err.message}`);
+      showUpgradePrompt();
+      process.exit(1);
+    }
+  } else {
+    const licenseStatus = getLicenseStatus(config);
+    if (licenseStatus && licenseStatus.type === 'pro') {
+      console.log(`[license] Pro license active.`);
+    }
+  }
+
+  const command = flags.command || 'run';
+
+  try {
+    switch (command) {
+      case 'scan': {
+        const result = await cmdScan(flags, config);
+        const outputPath = resolveOutputPath(flags);
+        const out = JSON.stringify({ fileTree: result.fileTree, filteredFiles: result.filteredFiles }, null, 2);
+        writeOutput(out, outputPath);
+        console.log(`[scan] Scan result written to: ${outputPath}`);
+        break;
+      }
+
+      case 'analyze': {
+        const scanResult = await cmdScan(flags, config);
+        const analyzeResult = await cmdAnalyze(flags, config, scanResult.filteredFiles);
+        const outputPath = resolveOutputPath(flags);
+        const out = JSON.stringify(analyzeResult, null, 2);
+        writeOutput(out, outputPath);
+        console.log(`[analyze] Analysis written to: ${outputPath}`);
+        break;
+      }
+
+      case 'bundle': {
+        const scanResult = await cmdScan(flags, config);
+        const analyzeResult = await cmdAnalyze(flags, config, scanResult.filteredFiles);
+        await cmdBundle(flags, config, scanResult, analyzeResult);
+        break;
+      }
+
+      case 'validate': {
+        const targetFile = flags.positional[0] || resolveOutputPath(flags);
+        const resolvedTarget = path.resolve(targetFile);
+
+        if (!fs.existsSync(resolvedTarget)) {
+          throw new Error(`Bundle file not found: ${resolvedTarget}`);
+        }
+
+        const content = fs.readFileSync(resolvedTarget, 'utf8');
+        let bundle;
+        try {
+          bundle = JSON.parse(content);
+        } catch {
+          throw new Error(`Could not parse bundle as JSON: ${resolvedTarget}`);
+        }
+
+        await cmdValidate(flags, config, bundle);
+        break;
+      }
+
+      case 'info': {
+        await cmdInfo(flags, config);
+        break;
+      }
+
+      case 'run': {
+        await cmdRun(flags, config);
+        break;
+      }
+
+      default:
+        console.error(`Unknown command: "${command}". Run "${TOOL_NAME} --help" for usage.`);
+        process.exit(1);
+    }
+  } catch (err) {
+    console.error(`\n[error] ${err.message}`);
+    if (process.env.DEBUG) {
+      console.error(err.stack);
+    }
+    process.exit(1);
+  }
+}
+
+main();