index.js

#!/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();