@craftpipe/contextpack 1.0.0

package/lib/bundler.js

@@ -0,0 +1,477 @@
+'use strict';
+
+const path = require('path');
+const { analyzeProject, buildDependencyGraph } = require('./analyzer');
+const { scanProject } = require('./scanner');
+
+/**
+ * Creates a compact context bundle from scanner and analyzer output
+ * @param {string} projectDir - Root directory of the project to bundle
+ * @param {object} options - Optional configuration options
+ * @param {string[]} [options.include] - Glob patterns to include
+ * @param {string[]} [options.exclude] - Glob patterns to exclude
+ * @param {boolean} [options.includeDependencyMap] - Whether to include dependency map
+ * @param {boolean} [options.includeSymbolIndex] - Whether to include symbol index
+ * @param {number} [options.maxFileSummaryLength] - Max characters per file summary
+ * @returns {object} Bundle object with fileSummaries, symbolIndex, dependencyMap, metadata
+ */
+function createBundle(projectDir, options) {
+  const opts = options || {};
+  const {
+    include,
+    exclude,
+    includeDependencyMap = true,
+    includeSymbolIndex = true,
+    maxFileSummaryLength = 500,
+  } = opts;
+
+  if (!projectDir || typeof projectDir !== 'string') {
+    return {
+      metadata: {
+        error: 'Invalid projectDir provided',
+        createdAt: new Date().toISOString(),
+        projectDir: projectDir || null,
+        fileCount: 0,
+        totalSize: 0,
+      },
+      fileSummaries: [],
+      symbolIndex: {},
+      dependencyMap: {},
+    };
+  }
+
+  let scanResult;
+  try {
+    scanResult = scanProject(projectDir, { include, exclude });
+  } catch (err) {
+    return {
+      metadata: {
+        error: `Scan failed: ${err.message}`,
+        createdAt: new Date().toISOString(),
+        projectDir,
+        fileCount: 0,
+        totalSize: 0,
+      },
+      fileSummaries: [],
+      symbolIndex: {},
+      dependencyMap: {},
+    };
+  }
+
+  const files = (scanResult && Array.isArray(scanResult.files)) ? scanResult.files : [];
+
+  let analysisResult;
+  try {
+    analysisResult = analyzeProject(projectDir, { include, exclude });
+  } catch (err) {
+    analysisResult = { symbolMap: {}, dependencies: {} };
+  }
+
+  const symbolMap = (analysisResult && analysisResult.symbolMap) ? analysisResult.symbolMap : {};
+  const dependencies = (analysisResult && analysisResult.dependencies) ? analysisResult.dependencies : {};
+
+  let dependencyGraph = {};
+  if (includeDependencyMap) {
+    try {
+      dependencyGraph = buildDependencyGraph(projectDir, { include, exclude }) || {};
+    } catch (err) {
+      dependencyGraph = dependencies || {};
+    }
+  }
+
+  const fileSummaries = buildFileSummaries(files, symbolMap, projectDir, maxFileSummaryLength);
+  const symbolIndex = includeSymbolIndex ? buildSymbolIndex(symbolMap, projectDir) : {};
+  const dependencyMap = includeDependencyMap ? buildDependencyMap(dependencyGraph, projectDir) : {};
+
+  const totalSize = files.reduce((sum, f) => sum + ((f && f.size) ? f.size : 0), 0);
+
+  return {
+    metadata: {
+      createdAt: new Date().toISOString(),
+      projectDir,
+      fileCount: files.length,
+      totalSize,
+      version: '1.0.0',
+    },
+    fileSummaries,
+    symbolIndex,
+    dependencyMap,
+  };
+}
+
+/**
+ * Build file summaries from scan results and symbol map
+ * @param {object[]} files - Array of file objects from scanner
+ * @param {object} symbolMap - Symbol map from analyzer
+ * @param {string} projectDir - Root project directory
+ * @param {number} maxLength - Max summary length
+ * @returns {object[]} Array of file summary objects
+ */
+function buildFileSummaries(files, symbolMap, projectDir, maxLength) {
+  if (!Array.isArray(files)) return [];
+
+  return files.map(function (file) {
+    if (!file) return null;
+
+    const filePath = file.path || file.absolutePath || '';
+    const relPath = projectDir ? path.relative(projectDir, filePath).replace(/\\/g, '/') : filePath;
+    const ext = path.extname(filePath).toLowerCase();
+
+    const fileSymbols = symbolMap[filePath] || symbolMap[relPath] || null;
+
+    const symbols = fileSymbols ? extractSymbolNames(fileSymbols) : [];
+    const imports = fileSymbols && fileSymbols.imports ? fileSymbols.imports : [];
+    const exports = fileSymbols && fileSymbols.exports ? fileSymbols.exports : [];
+
+    let summary = buildSummaryText(relPath, ext, symbols, exports, imports);
+    if (summary.length > maxLength) {
+      summary = summary.slice(0, maxLength - 3) + '...';
+    }
+
+    return {
+      path: relPath,
+      absolutePath: filePath,
+      size: file.size || 0,
+      extension: ext,
+      summary,
+      symbols,
+      exports,
+      imports,
+    };
+  }).filter(Boolean);
+}
+
+/**
+ * Extract symbol names from a file's symbol data
+ * @param {object} fileSymbols - Symbol data for a file
+ * @returns {string[]} Array of symbol names
+ */
+function extractSymbolNames(fileSymbols) {
+  if (!fileSymbols) return [];
+
+  const names = new Set();
+
+  if (Array.isArray(fileSymbols.functions)) {
+    fileSymbols.functions.forEach(function (fn) {
+      if (fn && fn.name) names.add(fn.name);
+      else if (typeof fn === 'string') names.add(fn);
+    });
+  }
+
+  if (Array.isArray(fileSymbols.classes)) {
+    fileSymbols.classes.forEach(function (cls) {
+      if (cls && cls.name) names.add(cls.name);
+      else if (typeof cls === 'string') names.add(cls);
+    });
+  }
+
+  if (Array.isArray(fileSymbols.symbols)) {
+    fileSymbols.symbols.forEach(function (sym) {
+      if (sym && sym.name) names.add(sym.name);
+      else if (typeof sym === 'string') names.add(sym);
+    });
+  }
+
+  return Array.from(names);
+}
+
+/**
+ * Build a human-readable summary text for a file
+ * @param {string} relPath - Relative file path
+ * @param {string} ext - File extension
+ * @param {string[]} symbols - Symbol names
+ * @param {string[]} exports - Export names
+ * @param {string[]} imports - Import sources
+ * @returns {string} Summary text
+ */
+function buildSummaryText(relPath, ext, symbols, exports, imports) {
+  const parts = [];
+
+  parts.push('File: ' + relPath);
+
+  if (ext) {
+    parts.push('Type: ' + ext.replace('.', '').toUpperCase());
+  }
+
+  if (symbols && symbols.length > 0) {
+    parts.push('Symbols: ' + symbols.slice(0, 10).join(', ') + (symbols.length > 10 ? ' ...' : ''));
+  }
+
+  if (exports && exports.length > 0) {
+    const exportNames = exports.map(function (e) {
+      return (e && typeof e === 'object') ? (e.name || e.value || JSON.stringify(e)) : String(e);
+    });
+    parts.push('Exports: ' + exportNames.slice(0, 10).join(', ') + (exportNames.length > 10 ? ' ...' : ''));
+  }
+
+  if (imports && imports.length > 0) {
+    const importSources = imports.map(function (imp) {
+      return (imp && typeof imp === 'object') ? (imp.source || imp.from || imp.module || JSON.stringify(imp)) : String(imp);
+    });
+    parts.push('Imports: ' + importSources.slice(0, 5).join(', ') + (importSources.length > 5 ? ' ...' : ''));
+  }
+
+  return parts.join(' | ');
+}
+
+/**
+ * Build a symbol index mapping symbol names to file paths
+ * @param {object} symbolMap - Symbol map from analyzer
+ * @param {string} projectDir - Root project directory
+ * @returns {object} Symbol index object
+ */
+function buildSymbolIndex(symbolMap, projectDir) {
+  if (!symbolMap || typeof symbolMap !== 'object') return {};
+
+  const index = {};
+
+  Object.keys(symbolMap).forEach(function (filePath) {
+    const fileSymbols = symbolMap[filePath];
+    if (!fileSymbols) return;
+
+    const relPath = projectDir
+      ? path.relative(projectDir, filePath).replace(/\\/g, '/')
+      : filePath;
+
+    const symbolNames = extractSymbolNames(fileSymbols);
+
+    symbolNames.forEach(function (name) {
+      if (!name) return;
+      if (!index[name]) {
+        index[name] = [];
+      }
+      if (!index[name].includes(relPath)) {
+        index[name].push(relPath);
+      }
+    });
+
+    if (Array.isArray(fileSymbols.exports)) {
+      fileSymbols.exports.forEach(function (exp) {
+        const expName = (exp && typeof exp === 'object') ? (exp.name || exp.value) : exp;
+        if (!expName || typeof expName !== 'string') return;
+        if (!index[expName]) {
+          index[expName] = [];
+        }
+        if (!index[expName].includes(relPath)) {
+          index[expName].push(relPath);
+        }
+      });
+    }
+  });
+
+  return index;
+}
+
+/**
+ * Build a dependency map from the dependency graph
+ * @param {object} dependencyGraph - Dependency graph from analyzer
+ * @param {string} projectDir - Root project directory
+ * @returns {object} Dependency map with relative paths
+ */
+function buildDependencyMap(dependencyGraph, projectDir) {
+  if (!dependencyGraph || typeof dependencyGraph !== 'object') return {};
+
+  const map = {};
+
+  Object.keys(dependencyGraph).forEach(function (filePath) {
+    const deps = dependencyGraph[filePath];
+    if (!deps) return;
+
+    const relPath = projectDir
+      ? path.relative(projectDir, filePath).replace(/\\/g, '/')
+      : filePath;
+
+    const relDeps = Array.isArray(deps)
+      ? deps.map(function (dep) {
+          if (!dep || typeof dep !== 'string') return dep;
+          if (dep.startsWith('.') || path.isAbsolute(dep)) {
+            try {
+              return projectDir
+                ? path.relative(projectDir, dep).replace(/\\/g, '/')
+                : dep;
+            } catch (e) {
+              return dep;
+            }
+          }
+          return dep;
+        }).filter(Boolean)
+      : [];
+
+    map[relPath] = relDeps;
+  });
+
+  return map;
+}
+
+/**
+ * Formats a bundle as a JSON string
+ * @param {object} bundle - Bundle object from createBundle
+ * @param {object} options - Formatting options
+ * @param {boolean} [options.pretty] - Whether to pretty-print the JSON (default: true)
+ * @returns {string} JSON string representation of the bundle
+ */
+function formatAsJSON(bundle, options) {
+  const opts = options || {};
+  const pretty = opts.pretty !== false;
+
+  if (!bundle || typeof bundle !== 'object') {
+    return pretty ? JSON.stringify({ error: 'Invalid bundle' }, null, 2) : JSON.stringify({ error: 'Invalid bundle' });
+  }
+
+  try {
+    return pretty ? JSON.stringify(bundle, null, 2) : JSON.stringify(bundle);
+  } catch (err) {
+    const fallback = { error: 'Failed to serialize bundle: ' + err.message };
+    return pretty ? JSON.stringify(fallback, null, 2) : JSON.stringify(fallback);
+  }
+}
+
+/**
+ * Formats a bundle as a Markdown document
+ * @param {object} bundle - Bundle object from createBundle
+ * @param {object} options - Formatting options
+ * @param {string} [options.title] - Document title (default: 'ContextPack Bundle')
+ * @param {boolean} [options.includeSymbolIndex] - Whether to include symbol index section
+ * @param {boolean} [options.includeDependencyMap] - Whether to include dependency map section
+ * @returns {string} Markdown string representation of the bundle
+ */
+function formatAsMarkdown(bundle, options) {
+  const opts = options || {};
+  const {
+    title = 'ContextPack Bundle',
+    includeSymbolIndex = true,
+    includeDependencyMap = true,
+  } = opts;
+
+  if (!bundle || typeof bundle !== 'object') {
+    return '# Error\n\nInvalid bundle provided.\n';
+  }
+
+  const lines = [];
+
+  lines.push('# ' + title);
+  lines.push('');
+
+  const meta = bundle.metadata || {};
+  lines.push('## Metadata');
+  lines.push('');
+  lines.push('| Property | Value |');
+  lines.push('|----------|-------|');
+  lines.push('| Created | ' + (meta.createdAt || 'N/A') + ' |');
+  lines.push('| Project | ' + (meta.projectDir || 'N/A') + ' |');
+  lines.push('| Files | ' + (meta.fileCount != null ? meta.fileCount : 'N/A') + ' |');
+  lines.push('| Total Size | ' + formatBytes(meta.totalSize || 0) + ' |');
+  if (meta.version) {
+    lines.push('| Version | ' + meta.version + ' |');
+  }
+  if (meta.error) {
+    lines.push('| Error | ' + meta.error + ' |');
+  }
+  lines.push('');
+
+  const fileSummaries = Array.isArray(bundle.fileSummaries) ? bundle.fileSummaries : [];
+  lines.push('## File Summaries');
+  lines.push('');
+
+  if (fileSummaries.length === 0) {
+    lines.push('_No files found._');
+    lines.push('');
+  } else {
+    fileSummaries.forEach(function (file) {
+      if (!file) return;
+      lines.push('### `' + (file.path || 'unknown') + '`');
+      lines.push('');
+      lines.push('- **Size:** ' + formatBytes(file.size || 0));
+      lines.push('- **Type:** ' + ((file.extension || '').replace('.', '').toUpperCase() || 'Unknown'));
+
+      if (file.symbols && file.symbols.length > 0) {
+        lines.push('- **Symbols:** ' + file.symbols.join(', '));
+      }
+
+      if (file.exports && file.exports.length > 0) {
+        const exportNames = file.exports.map(function (e) {
+          return (e && typeof e === 'object') ? (e.name || e.value || JSON.stringify(e)) : String(e);
+        });
+        lines.push('- **Exports:** ' + exportNames.join(', '));
+      }
+
+      if (file.imports && file.imports.length > 0) {
+        const importSources = file.imports.map(function (imp) {
+          return (imp && typeof imp === 'object') ? (imp.source || imp.from || imp.module || JSON.stringify(imp)) : String(imp);
+        });
+        lines.push('- **Imports:** ' + importSources.join(', '));
+      }
+
+      if (file.summary) {
+        lines.push('');
+        lines.push('> ' + file.summary.replace(/\n/g, ' '));
+      }
+
+      lines.push('');
+    });
+  }
+
+  if (includeSymbolIndex) {
+    const symbolIndex = (bundle.symbolIndex && typeof bundle.symbolIndex === 'object') ? bundle.symbolIndex : {};
+    const symbolKeys = Object.keys(symbolIndex);
+
+    lines.push('## Symbol Index');
+    lines.push('');
+
+    if (symbolKeys.length === 0) {
+      lines.push('_No symbols found._');
+      lines.push('');
+    } else {
+      lines.push('| Symbol | Defined In |');
+      lines.push('|--------|-----------|');
+      symbolKeys.sort().forEach(function (sym) {
+        const locations = Array.isArray(symbolIndex[sym]) ? symbolIndex[sym] : [symbolIndex[sym]];
+        lines.push('| `' + sym + '` | ' + locations.map(function (l) { return '`' + l + '`'; }).join(', ') + ' |');
+      });
+      lines.push('');
+    }
+  }
+
+  if (includeDependencyMap) {
+    const dependencyMap = (bundle.dependencyMap && typeof bundle.dependencyMap === 'object') ? bundle.dependencyMap : {};
+    const depKeys = Object.keys(dependencyMap);
+
+    lines.push('## Dependency Map');
+    lines.push('');
+
+    if (depKeys.length === 0) {
+      lines.push('_No dependencies found._');
+      lines.push('');
+    } else {
+      depKeys.sort().forEach(function (file) {
+        const deps = Array.isArray(dependencyMap[file]) ? dependencyMap[file] : [];
+        lines.push('**`' + file + '`**');
+        if (deps.length === 0) {
+          lines.push('- _(no dependencies)_');
+        } else {
+          deps.forEach(function (dep) {
+            lines.push('- `' + dep + '`');
+          });
+        }
+        lines.push('');
+      });
+    }
+  }
+
+  return lines.join('\n');
+}
+
+/**
+ * Format bytes into a human-readable string
+ * @param {number} bytes - Number of bytes
+ * @returns {string} Human-readable size string
+ */
+function formatBytes(bytes) {
+  if (!bytes || bytes === 0) return '0 B';
+  const units = ['B', 'KB', 'MB', 'GB'];
+  const i = Math.floor(Math.log(bytes) / Math.log(1024));
+  const val = (bytes / Math.pow(1024, i)).toFixed(i === 0 ? 0 : 1);
+  return val + ' ' + (units[i] || 'B');
+}
+
+module.exports = { createBundle, formatAsJSON, formatAsMarkdown };