vibecheck-ai 2.0.1 → 5.0.0

package/bin/runners/lib/packs/pack-factory.js

@@ -0,0 +1,837 @@
+// bin/runners/lib/packs/pack-factory.js
+// ═══════════════════════════════════════════════════════════════════════════════
+// PACK FACTORY - Unified artifact factory for shareable evidence bundles
+// "One command to produce ZIP + manifest + HTML index"
+// ═══════════════════════════════════════════════════════════════════════════════
+
+const fs = require('fs');
+const path = require('path');
+const crypto = require('crypto');
+const { execSync } = require('child_process');
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// CONSTANTS
+// ═══════════════════════════════════════════════════════════════════════════════
+
+const PACK_SCHEMA_VERSION = '1.0.0';
+const MANIFEST_SCHEMA = 'vibecheck/pack-manifest/v1';
+
+/**
+ * Pack types
+ */
+const PACK_TYPE = {
+  EVIDENCE: 'evidence',
+  PERMISSIONS: 'permissions',
+  PROOF_GRAPH: 'proof-graph',
+  REPORT: 'report',
+  LAUNCH: 'launch',
+  BUNDLE: 'bundle', // All-in-one bundle
+};
+
+/**
+ * Artifact types
+ */
+const ARTIFACT_TYPE = {
+  JSON: 'json',
+  HTML: 'html',
+  MARKDOWN: 'markdown',
+  PDF: 'pdf',
+  SARIF: 'sarif',
+  CSV: 'csv',
+  DOT: 'dot',
+  MERMAID: 'mermaid',
+  PNG: 'png',
+  SVG: 'svg',
+  ZIP: 'zip',
+  VIDEO: 'video',
+  TRACE: 'trace',
+  HAR: 'har',
+  SCREENSHOT: 'screenshot',
+};
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// STABLE NAMING SCHEME
+// ═══════════════════════════════════════════════════════════════════════════════
+
+/**
+ * Generate deterministic content hash
+ * @param {string|Buffer} content - Content to hash
+ * @returns {string} First 12 chars of SHA256
+ */
+function contentHash(content) {
+  return crypto.createHash('sha256').update(content).digest('hex').slice(0, 12);
+}
+
+/**
+ * Generate stable pack ID
+ * Format: {type}_{projectName}_{date}_{contentHash}
+ * @param {string} packType - Pack type
+ * @param {string} projectName - Project name
+ * @param {string} [hashSeed] - Optional content for hash
+ * @returns {string} Stable pack ID
+ */
+function generatePackId(packType, projectName, hashSeed = '') {
+  const sanitizedProject = (projectName || 'project')
+    .toLowerCase()
+    .replace(/[^a-z0-9]/g, '-')
+    .slice(0, 20);
+  
+  const date = new Date().toISOString().split('T')[0].replace(/-/g, '');
+  const hash = contentHash(`${packType}:${projectName}:${hashSeed}:${Date.now()}`);
+  
+  return `${packType}_${sanitizedProject}_${date}_${hash}`;
+}
+
+/**
+ * Generate stable artifact filename
+ * Format: {packId}_{artifactType}.{extension}
+ * @param {string} packId - Pack ID
+ * @param {string} artifactType - Artifact type
+ * @param {string} extension - File extension
+ * @returns {string} Artifact filename
+ */
+function generateArtifactFilename(packId, artifactType, extension) {
+  return `${packId}_${artifactType}.${extension}`;
+}
+
+/**
+ * Generate reproducible build fingerprint
+ * @param {object} data - Data to fingerprint
+ * @returns {string} Fingerprint hash
+ */
+function generateFingerprint(data) {
+  const normalized = JSON.stringify(data, Object.keys(data).sort());
+  return crypto.createHash('sha256').update(normalized).digest('hex');
+}
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// GIT INFO
+// ═══════════════════════════════════════════════════════════════════════════════
+
+/**
+ * Get git info for manifest
+ * @param {string} repoRoot - Repository root
+ * @returns {object} Git info
+ */
+function getGitInfo(repoRoot) {
+  try {
+    const commit = execSync('git rev-parse HEAD', { cwd: repoRoot, encoding: 'utf8', stdio: ['pipe', 'pipe', 'pipe'] }).trim();
+    const branch = execSync('git rev-parse --abbrev-ref HEAD', { cwd: repoRoot, encoding: 'utf8', stdio: ['pipe', 'pipe', 'pipe'] }).trim();
+    const dirty = execSync('git status --porcelain', { cwd: repoRoot, encoding: 'utf8', stdio: ['pipe', 'pipe', 'pipe'] }).trim().length > 0;
+    
+    let remoteUrl = null;
+    try {
+      remoteUrl = execSync('git remote get-url origin', { cwd: repoRoot, encoding: 'utf8', stdio: ['pipe', 'pipe', 'pipe'] }).trim();
+    } catch (e) {
+      // No remote
+    }
+    
+    return { commit, branch, dirty, remoteUrl };
+  } catch (e) {
+    return { commit: null, branch: null, dirty: false, remoteUrl: null };
+  }
+}
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// RECEIPT CROSS-LINKING
+// ═══════════════════════════════════════════════════════════════════════════════
+
+/**
+ * Load receipt if it exists
+ * @param {string} repoRoot - Repository root
+ * @param {string} receiptPath - Relative path to receipt
+ * @returns {object|null} Receipt or null
+ */
+function loadReceipt(repoRoot, receiptPath) {
+  const fullPath = path.join(repoRoot, receiptPath);
+  if (!fs.existsSync(fullPath)) return null;
+  
+  try {
+    return JSON.parse(fs.readFileSync(fullPath, 'utf8'));
+  } catch (e) {
+    return null;
+  }
+}
+
+/**
+ * Collect all available receipts
+ * @param {string} repoRoot - Repository root
+ * @returns {object} Receipt references
+ */
+function collectReceiptReferences(repoRoot) {
+  const references = {
+    ship: null,
+    reality: null,
+    shield: null,
+    diagnosis: null,
+    scan: null,
+  };
+  
+  // Ship receipt
+  const shipManifest = loadReceipt(repoRoot, '.vibecheck/ship/manifest.json');
+  if (shipManifest) {
+    references.ship = {
+      path: '.vibecheck/ship/manifest.json',
+      verdict: shipManifest.verdict?.status,
+      timestamp: shipManifest.generatedAt,
+      fingerprint: shipManifest.fingerprint,
+    };
+  }
+  
+  // Reality receipt (find latest)
+  const receiptsDir = path.join(repoRoot, '.vibecheck/receipts');
+  if (fs.existsSync(receiptsDir)) {
+    const receipts = fs.readdirSync(receiptsDir, { withFileTypes: true })
+      .filter(d => d.isDirectory())
+      .map(d => d.name)
+      .sort()
+      .reverse();
+    
+    if (receipts.length > 0) {
+      const latestReceipt = loadReceipt(repoRoot, `.vibecheck/receipts/${receipts[0]}/manifest.json`);
+      if (latestReceipt) {
+        references.reality = {
+          path: `.vibecheck/receipts/${receipts[0]}/manifest.json`,
+          runId: receipts[0],
+          verdict: latestReceipt.verdict,
+          timestamp: latestReceipt.createdAt,
+        };
+      }
+    }
+  }
+  
+  // Scan results
+  const scanResults = loadReceipt(repoRoot, '.vibecheck/results/latest.json');
+  if (scanResults) {
+    references.scan = {
+      path: '.vibecheck/results/latest.json',
+      findingCount: scanResults.findings?.length || 0,
+      timestamp: scanResults.timestamp,
+    };
+  }
+  
+  return references;
+}
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// MANIFEST SCHEMA
+// ═══════════════════════════════════════════════════════════════════════════════
+
+/**
+ * Create pack manifest
+ * @param {object} options - Manifest options
+ * @returns {object} Manifest object
+ */
+function createManifest(options) {
+  const {
+    packId,
+    packType,
+    projectName,
+    repoRoot,
+    artifacts = [],
+    metadata = {},
+  } = options;
+  
+  const gitInfo = getGitInfo(repoRoot);
+  const receipts = collectReceiptReferences(repoRoot);
+  
+  const manifest = {
+    $schema: MANIFEST_SCHEMA,
+    schemaVersion: PACK_SCHEMA_VERSION,
+    
+    // Identity
+    id: packId,
+    type: packType,
+    
+    // Timestamps
+    generatedAt: new Date().toISOString(),
+    expiresAt: null, // Optional TTL
+    
+    // Project info
+    project: {
+      name: projectName,
+      root: repoRoot,
+    },
+    
+    // Git info
+    git: gitInfo,
+    
+    // Build info (for reproducibility)
+    build: {
+      fingerprint: generateFingerprint({
+        packId,
+        packType,
+        projectName,
+        artifacts: artifacts.map(a => a.hash),
+        gitCommit: gitInfo.commit,
+      }),
+      reproducible: !gitInfo.dirty,
+      nodeVersion: process.version,
+      platform: process.platform,
+    },
+    
+    // Cross-references to receipts
+    receipts,
+    
+    // Artifacts in this pack
+    artifacts: artifacts.map(a => ({
+      filename: a.filename,
+      type: a.type,
+      size: a.size,
+      hash: a.hash,
+      description: a.description,
+    })),
+    
+    // Pack-specific metadata
+    metadata,
+    
+    // Summary
+    summary: {
+      artifactCount: artifacts.length,
+      totalSize: artifacts.reduce((sum, a) => sum + (a.size || 0), 0),
+    },
+  };
+  
+  return manifest;
+}
+
+/**
+ * Validate manifest against schema
+ * @param {object} manifest - Manifest to validate
+ * @returns {{ valid: boolean, errors: string[] }}
+ */
+function validateManifest(manifest) {
+  const errors = [];
+  
+  if (!manifest.$schema) errors.push('Missing $schema');
+  if (!manifest.id) errors.push('Missing id');
+  if (!manifest.type) errors.push('Missing type');
+  if (!manifest.generatedAt) errors.push('Missing generatedAt');
+  if (!manifest.project?.name) errors.push('Missing project.name');
+  if (!manifest.build?.fingerprint) errors.push('Missing build.fingerprint');
+  if (!Array.isArray(manifest.artifacts)) errors.push('Missing artifacts array');
+  
+  return { valid: errors.length === 0, errors };
+}
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// HTML INDEX GENERATION
+// ═══════════════════════════════════════════════════════════════════════════════
+
+/**
+ * Generate HTML index for pack
+ * @param {object} manifest - Pack manifest
+ * @param {object} options - Generation options
+ * @returns {string} HTML content
+ */
+function generateHtmlIndex(manifest, options = {}) {
+  const { includeEmbeddedData = true } = options;
+  
+  const artifactRows = manifest.artifacts.map(a => `
+    <tr>
+      <td><a href="${a.filename}" class="artifact-link">${a.filename}</a></td>
+      <td><span class="badge badge-${a.type}">${a.type}</span></td>
+      <td>${formatSize(a.size)}</td>
+      <td class="hash">${a.hash?.slice(0, 12) || 'N/A'}...</td>
+    </tr>
+  `).join('');
+  
+  const receiptLinks = [];
+  if (manifest.receipts?.ship) {
+    receiptLinks.push(`<a href="#" class="receipt-link ship">Ship: ${manifest.receipts.ship.verdict || 'N/A'}</a>`);
+  }
+  if (manifest.receipts?.reality) {
+    receiptLinks.push(`<a href="#" class="receipt-link reality">Reality: ${manifest.receipts.reality.verdict || 'N/A'}</a>`);
+  }
+  if (manifest.receipts?.scan) {
+    receiptLinks.push(`<a href="#" class="receipt-link scan">Scan: ${manifest.receipts.scan.findingCount} findings</a>`);
+  }
+  
+  return `<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <title>Vibecheck Pack: ${manifest.id}</title>
+  <style>
+    :root {
+      --bg: #0d1117;
+      --surface: #161b22;
+      --border: #30363d;
+      --text: #c9d1d9;
+      --text-muted: #8b949e;
+      --accent: #ff9650;
+      --success: #3fb950;
+      --warning: #d29922;
+      --danger: #f85149;
+      --info: #58a6ff;
+    }
+    
+    * { box-sizing: border-box; margin: 0; padding: 0; }
+    
+    body {
+      font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Helvetica, Arial, sans-serif;
+      background: var(--bg);
+      color: var(--text);
+      line-height: 1.6;
+      padding: 2rem;
+    }
+    
+    .container { max-width: 1200px; margin: 0 auto; }
+    
+    header {
+      background: var(--surface);
+      border: 1px solid var(--border);
+      border-radius: 8px;
+      padding: 2rem;
+      margin-bottom: 2rem;
+    }
+    
+    h1 {
+      font-size: 1.5rem;
+      color: var(--accent);
+      margin-bottom: 0.5rem;
+    }
+    
+    .pack-id {
+      font-family: monospace;
+      font-size: 0.875rem;
+      color: var(--text-muted);
+    }
+    
+    .meta-grid {
+      display: grid;
+      grid-template-columns: repeat(auto-fit, minmax(200px, 1fr));
+      gap: 1rem;
+      margin-top: 1.5rem;
+    }
+    
+    .meta-item {
+      background: var(--bg);
+      border-radius: 6px;
+      padding: 1rem;
+    }
+    
+    .meta-label {
+      font-size: 0.75rem;
+      color: var(--text-muted);
+      text-transform: uppercase;
+      letter-spacing: 0.05em;
+    }
+    
+    .meta-value {
+      font-size: 1rem;
+      margin-top: 0.25rem;
+    }
+    
+    section {
+      background: var(--surface);
+      border: 1px solid var(--border);
+      border-radius: 8px;
+      padding: 1.5rem;
+      margin-bottom: 1.5rem;
+    }
+    
+    h2 {
+      font-size: 1.125rem;
+      margin-bottom: 1rem;
+      padding-bottom: 0.5rem;
+      border-bottom: 1px solid var(--border);
+    }
+    
+    table {
+      width: 100%;
+      border-collapse: collapse;
+    }
+    
+    th, td {
+      padding: 0.75rem;
+      text-align: left;
+      border-bottom: 1px solid var(--border);
+    }
+    
+    th {
+      font-size: 0.75rem;
+      color: var(--text-muted);
+      text-transform: uppercase;
+      letter-spacing: 0.05em;
+    }
+    
+    .artifact-link {
+      color: var(--info);
+      text-decoration: none;
+    }
+    
+    .artifact-link:hover {
+      text-decoration: underline;
+    }
+    
+    .badge {
+      display: inline-block;
+      padding: 0.25rem 0.5rem;
+      border-radius: 4px;
+      font-size: 0.75rem;
+      font-weight: 500;
+    }
+    
+    .badge-json { background: #1f6feb33; color: #58a6ff; }
+    .badge-html { background: #8957e533; color: #d2a8ff; }
+    .badge-markdown { background: #3fb95033; color: #56d364; }
+    .badge-pdf { background: #f8514933; color: #ff7b72; }
+    .badge-sarif { background: #d2992233; color: #e3b341; }
+    .badge-screenshot { background: #a371f733; color: #d2a8ff; }
+    .badge-video { background: #f778ba33; color: #ff9bce; }
+    .badge-trace { background: #79c0ff33; color: #a5d6ff; }
+    
+    .hash {
+      font-family: monospace;
+      font-size: 0.8rem;
+      color: var(--text-muted);
+    }
+    
+    .receipts {
+      display: flex;
+      gap: 0.5rem;
+      flex-wrap: wrap;
+    }
+    
+    .receipt-link {
+      display: inline-block;
+      padding: 0.5rem 1rem;
+      border-radius: 6px;
+      text-decoration: none;
+      font-size: 0.875rem;
+    }
+    
+    .receipt-link.ship { background: var(--success)22; color: var(--success); }
+    .receipt-link.reality { background: var(--info)22; color: var(--info); }
+    .receipt-link.scan { background: var(--warning)22; color: var(--warning); }
+    
+    footer {
+      text-align: center;
+      color: var(--text-muted);
+      font-size: 0.875rem;
+      margin-top: 2rem;
+      padding-top: 2rem;
+      border-top: 1px solid var(--border);
+    }
+    
+    .fingerprint {
+      font-family: monospace;
+      font-size: 0.75rem;
+      color: var(--text-muted);
+      word-break: break-all;
+    }
+  </style>
+</head>
+<body>
+  <div class="container">
+    <header>
+      <h1>${manifest.type.toUpperCase()} PACK</h1>
+      <div class="pack-id">${manifest.id}</div>
+      
+      <div class="meta-grid">
+        <div class="meta-item">
+          <div class="meta-label">Project</div>
+          <div class="meta-value">${manifest.project.name}</div>
+        </div>
+        <div class="meta-item">
+          <div class="meta-label">Generated</div>
+          <div class="meta-value">${new Date(manifest.generatedAt).toLocaleString()}</div>
+        </div>
+        <div class="meta-item">
+          <div class="meta-label">Artifacts</div>
+          <div class="meta-value">${manifest.summary.artifactCount} files (${formatSize(manifest.summary.totalSize)})</div>
+        </div>
+        <div class="meta-item">
+          <div class="meta-label">Git</div>
+          <div class="meta-value">${manifest.git.branch || 'N/A'} @ ${manifest.git.commit?.slice(0, 7) || 'N/A'}${manifest.git.dirty ? ' (dirty)' : ''}</div>
+        </div>
+      </div>
+    </header>
+    
+    ${receiptLinks.length > 0 ? `
+    <section>
+      <h2>Cross-References</h2>
+      <div class="receipts">
+        ${receiptLinks.join('')}
+      </div>
+    </section>
+    ` : ''}
+    
+    <section>
+      <h2>Artifacts</h2>
+      <table>
+        <thead>
+          <tr>
+            <th>Filename</th>
+            <th>Type</th>
+            <th>Size</th>
+            <th>Hash</th>
+          </tr>
+        </thead>
+        <tbody>
+          ${artifactRows}
+        </tbody>
+      </table>
+    </section>
+    
+    <section>
+      <h2>Build Info</h2>
+      <p><strong>Reproducible:</strong> ${manifest.build.reproducible ? 'Yes' : 'No (dirty working tree)'}</p>
+      <p><strong>Node:</strong> ${manifest.build.nodeVersion}</p>
+      <p><strong>Platform:</strong> ${manifest.build.platform}</p>
+      <p class="fingerprint"><strong>Fingerprint:</strong> ${manifest.build.fingerprint}</p>
+    </section>
+    
+    <footer>
+      <p>Generated by <strong>Vibecheck</strong> v${PACK_SCHEMA_VERSION}</p>
+      <p>Schema: ${manifest.$schema}</p>
+    </footer>
+  </div>
+  
+  ${includeEmbeddedData ? `
+  <script>
+    // Embedded manifest data for programmatic access
+    window.VIBECHECK_MANIFEST = ${JSON.stringify(manifest, null, 2)};
+  </script>
+  ` : ''}
+</body>
+</html>`;
+}
+
+/**
+ * Format file size for display
+ * @param {number} bytes - Size in bytes
+ * @returns {string} Formatted size
+ */
+function formatSize(bytes) {
+  if (!bytes || bytes === 0) return '0 B';
+  const units = ['B', 'KB', 'MB', 'GB'];
+  const i = Math.floor(Math.log(bytes) / Math.log(1024));
+  return `${(bytes / Math.pow(1024, i)).toFixed(1)} ${units[i]}`;
+}
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// PACK BUILDER
+// ═══════════════════════════════════════════════════════════════════════════════
+
+/**
+ * Pack builder class - fluent API for building packs
+ */
+class PackBuilder {
+  constructor(packType, repoRoot) {
+    this.packType = packType;
+    this.repoRoot = repoRoot;
+    this.projectName = path.basename(repoRoot);
+    this.artifacts = [];
+    this.metadata = {};
+    this.packId = null;
+    this.outputDir = null;
+  }
+  
+  /**
+   * Set pack ID (or auto-generate)
+   */
+  withId(id) {
+    this.packId = id;
+    return this;
+  }
+  
+  /**
+   * Set output directory
+   */
+  outputTo(dir) {
+    this.outputDir = dir;
+    return this;
+  }
+  
+  /**
+   * Add artifact to pack
+   */
+  addArtifact(filename, content, type, description = '') {
+    const contentBuffer = typeof content === 'string' ? Buffer.from(content, 'utf8') : content;
+    const hash = crypto.createHash('sha256').update(contentBuffer).digest('hex');
+    
+    this.artifacts.push({
+      filename,
+      content: contentBuffer,
+      type,
+      size: contentBuffer.length,
+      hash,
+      description,
+    });
+    
+    return this;
+  }
+  
+  /**
+   * Add file from disk to pack
+   */
+  addFile(srcPath, destFilename, type, description = '') {
+    const fullPath = path.isAbsolute(srcPath) ? srcPath : path.join(this.repoRoot, srcPath);
+    
+    if (!fs.existsSync(fullPath)) {
+      console.warn(`File not found, skipping: ${srcPath}`);
+      return this;
+    }
+    
+    const content = fs.readFileSync(fullPath);
+    const hash = crypto.createHash('sha256').update(content).digest('hex');
+    
+    this.artifacts.push({
+      filename: destFilename || path.basename(srcPath),
+      content,
+      type,
+      size: content.length,
+      hash,
+      description,
+      sourcePath: srcPath,
+    });
+    
+    return this;
+  }
+  
+  /**
+   * Add metadata
+   */
+  withMetadata(metadata) {
+    this.metadata = { ...this.metadata, ...metadata };
+    return this;
+  }
+  
+  /**
+   * Build the pack
+   */
+  build() {
+    // Generate pack ID if not set
+    if (!this.packId) {
+      const hashSeed = this.artifacts.map(a => a.hash).join(':');
+      this.packId = generatePackId(this.packType, this.projectName, hashSeed);
+    }
+    
+    // Determine output directory
+    if (!this.outputDir) {
+      this.outputDir = path.join(this.repoRoot, '.vibecheck', 'packs', this.packId);
+    }
+    
+    // Ensure output directory exists
+    fs.mkdirSync(this.outputDir, { recursive: true });
+    
+    // Write artifacts
+    for (const artifact of this.artifacts) {
+      const destPath = path.join(this.outputDir, artifact.filename);
+      fs.mkdirSync(path.dirname(destPath), { recursive: true });
+      fs.writeFileSync(destPath, artifact.content);
+    }
+    
+    // Create manifest
+    const manifest = createManifest({
+      packId: this.packId,
+      packType: this.packType,
+      projectName: this.projectName,
+      repoRoot: this.repoRoot,
+      artifacts: this.artifacts,
+      metadata: this.metadata,
+    });
+    
+    // Write manifest
+    const manifestPath = path.join(this.outputDir, 'manifest.json');
+    fs.writeFileSync(manifestPath, JSON.stringify(manifest, null, 2), 'utf8');
+    
+    // Generate and write HTML index
+    const htmlIndex = generateHtmlIndex(manifest);
+    const indexPath = path.join(this.outputDir, 'index.html');
+    fs.writeFileSync(indexPath, htmlIndex, 'utf8');
+    
+    return {
+      packId: this.packId,
+      outputDir: this.outputDir,
+      manifest,
+      artifactCount: this.artifacts.length,
+      manifestPath,
+      indexPath,
+    };
+  }
+  
+  /**
+   * Build and create ZIP bundle
+   */
+  async buildZip() {
+    const result = this.build();
+    
+    // Try to create ZIP
+    try {
+      const archiver = require('archiver');
+      const zipPath = `${result.outputDir}.zip`;
+      
+      const output = fs.createWriteStream(zipPath);
+      const archive = archiver('zip', { zlib: { level: 9 } });
+      
+      return new Promise((resolve, reject) => {
+        output.on('close', () => {
+          resolve({
+            ...result,
+            zipPath,
+            zipSize: archive.pointer(),
+          });
+        });
+        
+        archive.on('error', reject);
+        archive.pipe(output);
+        archive.directory(result.outputDir, false);
+        archive.finalize();
+      });
+    } catch (e) {
+      // archiver not available - return directory result
+      return result;
+    }
+  }
+}
+
+/**
+ * Create a new pack builder
+ * @param {string} packType - Pack type
+ * @param {string} repoRoot - Repository root
+ * @returns {PackBuilder}
+ */
+function createPackBuilder(packType, repoRoot) {
+  return new PackBuilder(packType, repoRoot);
+}
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// EXPORTS
+// ═══════════════════════════════════════════════════════════════════════════════
+
+module.exports = {
+  // Constants
+  PACK_SCHEMA_VERSION,
+  MANIFEST_SCHEMA,
+  PACK_TYPE,
+  ARTIFACT_TYPE,
+  
+  // Naming
+  generatePackId,
+  generateArtifactFilename,
+  generateFingerprint,
+  contentHash,
+  
+  // Manifest
+  createManifest,
+  validateManifest,
+  
+  // HTML
+  generateHtmlIndex,
+  formatSize,
+  
+  // Receipts
+  loadReceipt,
+  collectReceiptReferences,
+  
+  // Git
+  getGitInfo,
+  
+  // Builder
+  PackBuilder,
+  createPackBuilder,
+};