@vibgrate/cli 1.0.65 → 1.0.66

package/dist/{baseline-WRLXEJGA.js → baseline-IEG2JITU.js}

@@ -1,8 +1,8 @@
 import {
   baselineCommand,
   runBaseline
-} from "./chunk-VGZRUFB4.js";
-import "./chunk-XDZGC6KJ.js";
+} from "./chunk-IHDUX5MC.js";
+import "./chunk-DMYMJUQP.js";
 import "./chunk-TBE6NQ5Z.js";
 export {
   baselineCommand,

package/dist/{chunk-XDZGC6KJ.js → chunk-DMYMJUQP.js}

@@ -1169,6 +1169,260 @@ import * as crypto3 from "crypto";
 import * as path2 from "path";
 import { Command as Command2 } from "commander";
 import chalk3 from "chalk";
+
+// src/utils/compact-artifact.ts
+import * as zlib from "zlib";
+import { promisify } from "util";
+
+// src/utils/compact-evidence.ts
+var CATEGORY_PATTERNS = [
+  { category: "pricing", pattern: /price|pricing|billing|subscri|trial|credit|plan|tier|upgrade|premium|pro|enterprise/i },
+  { category: "auth", pattern: /sign[- ]?in|sign[- ]?up|log[- ]?in|log[- ]?out|auth|sso|oauth|password|register|invite|onboard/i },
+  { category: "dashboard", pattern: /dashboard|overview|home|main|summary|stats/i },
+  { category: "settings", pattern: /setting|config|preference|option|profile|account/i },
+  { category: "users", pattern: /user|member|team|role|permission|access|admin|owner/i },
+  { category: "integrations", pattern: /integrat|connect|webhook|api[- ]?key|sync|import|export/i },
+  { category: "reports", pattern: /report|analy|metric|chart|graph|insight|track/i },
+  { category: "workflows", pattern: /workflow|automat|schedule|trigger|action|job|task|pipeline/i },
+  { category: "projects", pattern: /project|workspace|organization|folder|repo/i },
+  { category: "navigation", pattern: /menu|nav|sidebar|header|footer|breadcrumb/i }
+];
+function compactUiPurpose(result, maxSamplesPerCategory = 3) {
+  const evidence = result.topEvidence;
+  const dependencies = evidence.filter((e) => e.kind === "dependency").map((e) => e.value).slice(0, 10);
+  const routes = dedupeRoutes(
+    evidence.filter((e) => e.kind === "route").map((e) => e.value)
+  ).slice(0, 15);
+  const textEvidence = evidence.filter(
+    (e) => e.kind !== "dependency" && e.kind !== "route" && e.kind !== "feature_flag"
+  );
+  const byCategory = /* @__PURE__ */ new Map();
+  const categoryCounts = {};
+  for (const item of textEvidence) {
+    const category = categorize(item.value);
+    if (!byCategory.has(category)) {
+      byCategory.set(category, /* @__PURE__ */ new Set());
+    }
+    const normalized = normalizeValue(item.value);
+    if (normalized.length >= 3) {
+      byCategory.get(category).add(normalized);
+    }
+  }
+  const samples = [];
+  for (const [category, values] of byCategory) {
+    const deduped = dedupeStrings([...values]);
+    categoryCounts[category] = deduped.length;
+    for (const value of deduped.slice(0, maxSamplesPerCategory)) {
+      samples.push({ kind: "text", value, category });
+    }
+  }
+  const featureFlags = evidence.filter((e) => e.kind === "feature_flag");
+  if (featureFlags.length > 0) {
+    categoryCounts["feature_flags"] = featureFlags.length;
+    samples.push({ kind: "feature_flag", value: "feature flags detected", category: "feature_flags" });
+  }
+  return {
+    samples,
+    categoryCounts,
+    originalCount: evidence.length,
+    dependencies,
+    routes,
+    detectedFrameworks: result.detectedFrameworks
+  };
+}
+function categorize(value) {
+  for (const { category, pattern } of CATEGORY_PATTERNS) {
+    if (pattern.test(value)) return category;
+  }
+  return "general";
+}
+function normalizeValue(value) {
+  return value.toLowerCase().replace(/[^a-z0-9\s-]/g, " ").replace(/\s+/g, " ").trim().slice(0, 60);
+}
+function dedupeStrings(values) {
+  const sorted = values.sort((a, b) => b.length - a.length);
+  const kept = [];
+  for (const value of sorted) {
+    const isDupe = kept.some((k) => {
+      const stem = value.slice(0, 6);
+      return k.startsWith(stem) || k.includes(value) || value.includes(k);
+    });
+    if (!isDupe) {
+      kept.push(value);
+    }
+  }
+  return kept;
+}
+function dedupeRoutes(routes) {
+  const seen = /* @__PURE__ */ new Set();
+  const result = [];
+  for (const route of routes) {
+    const normalized = route.replace(/:[a-z_]+/gi, ":param").replace(/\[\[*\.*\.*[a-z_]+\]*\]/gi, ":param").replace(/\/+$/, "").toLowerCase();
+    if (!seen.has(normalized)) {
+      seen.add(normalized);
+      result.push(route);
+    }
+  }
+  return result;
+}
+
+// src/utils/compact-artifact.ts
+var gzip2 = promisify(zlib.gzip);
+var MAX_ITEMS = 50;
+function extractName(entry) {
+  const match = entry.match(/^(.+?)\s*\(/);
+  return match ? match[1].trim() : entry.trim();
+}
+function compactDataStores(result) {
+  return {
+    databaseTechnologies: result.databaseTechnologies.slice(0, 10),
+    connectionStrings: [],
+    // Don't include connection strings in upload
+    connectionPoolSettings: result.connectionPoolSettings.slice(0, MAX_ITEMS),
+    replicationSettings: result.replicationSettings.slice(0, 20),
+    readReplicaSettings: result.readReplicaSettings.slice(0, 20),
+    failoverSettings: result.failoverSettings.slice(0, 20),
+    collationAndEncoding: result.collationAndEncoding.slice(0, 20),
+    queryTimeoutDefaults: result.queryTimeoutDefaults.slice(0, 20),
+    manualIndexes: result.manualIndexes.map(extractName).slice(0, MAX_ITEMS),
+    tables: result.tables.map(extractName).slice(0, MAX_ITEMS),
+    views: result.views.map(extractName).slice(0, MAX_ITEMS),
+    storedProcedures: result.storedProcedures.map(extractName).slice(0, MAX_ITEMS),
+    triggers: result.triggers.map(extractName).slice(0, MAX_ITEMS),
+    rowLevelSecurityPolicies: result.rowLevelSecurityPolicies.slice(0, 20),
+    otherServices: result.otherServices.slice(0, 20)
+  };
+}
+function compactApiSurface(result) {
+  const seenProviders = /* @__PURE__ */ new Set();
+  const uniqueIntegrations = result.integrations.filter((i) => {
+    const domain = i.provider.split(":")[0];
+    if (seenProviders.has(domain)) return false;
+    seenProviders.add(domain);
+    return true;
+  }).slice(0, MAX_ITEMS).map((i) => ({
+    provider: i.provider,
+    endpoint: "",
+    // Don't include full endpoints
+    version: i.version,
+    parameters: [],
+    // Don't include params
+    configOptions: [],
+    authHints: []
+  }));
+  return {
+    integrations: uniqueIntegrations,
+    openApiSpecifications: result.openApiSpecifications.slice(0, 10),
+    webhookUrls: result.webhookUrls.slice(0, 20),
+    callbackEndpoints: result.callbackEndpoints.slice(0, 20),
+    apiVersionPins: result.apiVersionPins.slice(0, 20),
+    tokenExpirationPolicies: result.tokenExpirationPolicies.slice(0, 20),
+    rateLimitOverrides: result.rateLimitOverrides.slice(0, 20),
+    customHeaders: result.customHeaders.slice(0, 20),
+    corsPolicies: result.corsPolicies.slice(0, 20),
+    oauthScopes: result.oauthScopes.slice(0, 20),
+    apiTokens: []
+    // Don't include token references
+  };
+}
+function compactAssetBranding(result) {
+  return {
+    faviconFiles: result.faviconFiles.slice(0, 1),
+    productLogos: []
+    // Don't include logos
+  };
+}
+function prepareArtifactForUpload(artifact) {
+  const compacted = { ...artifact };
+  if (compacted.extended) {
+    const ext = { ...compacted.extended };
+    if (ext.dataStores) {
+      ext.dataStores = compactDataStores(ext.dataStores);
+    }
+    if (ext.apiSurface) {
+      ext.apiSurface = compactApiSurface(ext.apiSurface);
+    }
+    if (ext.assetBranding) {
+      ext.assetBranding = compactAssetBranding(ext.assetBranding);
+    }
+    if (ext.uiPurpose) {
+      const compactedUi = compactUiPurpose(ext.uiPurpose);
+      ext.uiPurpose = {
+        enabled: ext.uiPurpose.enabled,
+        detectedFrameworks: compactedUi.detectedFrameworks,
+        evidenceCount: compactedUi.originalCount,
+        capped: ext.uiPurpose.capped,
+        topEvidence: [],
+        // Clear full evidence
+        unknownSignals: [],
+        // Add compacted data under extended properties
+        ...{ compacted: compactedUi }
+      };
+    }
+    if (ext.runtimeConfiguration) {
+      ext.runtimeConfiguration = {
+        ...ext.runtimeConfiguration,
+        environmentVariables: ext.runtimeConfiguration.environmentVariables.slice(0, 100),
+        hiddenConfigFiles: ext.runtimeConfiguration.hiddenConfigFiles.slice(0, MAX_ITEMS),
+        startupArguments: ext.runtimeConfiguration.startupArguments.slice(0, 100)
+      };
+    }
+    if (ext.operationalResilience) {
+      const ops = ext.operationalResilience;
+      ext.operationalResilience = {
+        implicitTimeouts: ops.implicitTimeouts.slice(0, 30),
+        defaultPaginationSize: ops.defaultPaginationSize.slice(0, 30),
+        implicitRetryLogic: ops.implicitRetryLogic.slice(0, 30),
+        defaultLocale: ops.defaultLocale.slice(0, 20),
+        defaultCurrency: ops.defaultCurrency.slice(0, 20),
+        implicitTimezone: ops.implicitTimezone.slice(0, 20),
+        defaultCharacterEncoding: ops.defaultCharacterEncoding.slice(0, 20),
+        sessionStores: ops.sessionStores.slice(0, 20),
+        distributedLocks: ops.distributedLocks.slice(0, 20),
+        jobSchedulers: ops.jobSchedulers.slice(0, 30),
+        idempotencyKeys: ops.idempotencyKeys.slice(0, 20),
+        rateLimitingCounters: ops.rateLimitingCounters.slice(0, 20),
+        circuitBreakerState: ops.circuitBreakerState.slice(0, 20),
+        abTestToggles: ops.abTestToggles.slice(0, 20),
+        regionalEnablementRules: ops.regionalEnablementRules.slice(0, 20),
+        betaAccessGroups: ops.betaAccessGroups.slice(0, 20),
+        licensingEnforcementLogic: ops.licensingEnforcementLogic.slice(0, 20),
+        killSwitches: ops.killSwitches.slice(0, 20),
+        connectorRetryLogic: ops.connectorRetryLogic.slice(0, 20),
+        apiPollingIntervals: ops.apiPollingIntervals.slice(0, 20),
+        fieldMappings: ops.fieldMappings.slice(0, 20),
+        schemaRegistryRules: ops.schemaRegistryRules.slice(0, 20),
+        deadLetterQueueBehavior: ops.deadLetterQueueBehavior.slice(0, 20),
+        dataMaskingRules: ops.dataMaskingRules.slice(0, 20),
+        transformationLogic: ops.transformationLogic.slice(0, 20),
+        timezoneHandling: ops.timezoneHandling.slice(0, 20),
+        encryptionSettings: ops.encryptionSettings.slice(0, 30),
+        hardcodedSecretSignals: ops.hardcodedSecretSignals.slice(0, 20)
+      };
+    }
+    if (ext.dependencyGraph) {
+      ext.dependencyGraph = {
+        ...ext.dependencyGraph,
+        phantomDependencies: ext.dependencyGraph.phantomDependencies.slice(0, MAX_ITEMS),
+        phantomDependencyDetails: ext.dependencyGraph.phantomDependencyDetails?.slice(0, MAX_ITEMS),
+        duplicatedPackages: ext.dependencyGraph.duplicatedPackages.slice(0, MAX_ITEMS)
+      };
+    }
+    compacted.extended = ext;
+  }
+  return compacted;
+}
+async function compressArtifact(artifact) {
+  const json = JSON.stringify(artifact);
+  return gzip2(json, { level: 9 });
+}
+async function prepareCompressedUpload(artifact) {
+  const compacted = prepareArtifactForUpload(artifact);
+  const compressed = await compressArtifact(compacted);
+  return { body: compressed, contentEncoding: "gzip" };
+}
+
+// src/commands/push.ts
 function parseDsn(dsn) {
   const cleaned = dsn.replace(/[\x00-\x1F\x7F\uFEFF\u200B-\u200D\u2060]/g, "").trim();
   const match = cleaned.match(/^vibgrate\+(https?):?\/\/([^:]+):([^@]+)@([^/]+)\/(.+)$/);
@@ -1203,7 +1457,8 @@ var pushCommand = new Command2("push").description("Push scan results to Vibgrat
     if (opts.strict) process.exit(1);
     return;
   }
-  const body = await readTextFile(filePath);
+  const artifact = await readJsonFile(filePath);
+  const { body, contentEncoding } = await prepareCompressedUpload(artifact);
   const timestamp = String(Date.now());
   let host = parsed.host;
   if (opts.region) {
@@ -1216,12 +1471,16 @@ var pushCommand = new Command2("push").description("Push scan results to Vibgrat
     }
   }
   const url = `${parsed.scheme}://${host}/v1/ingest/scan`;
-  console.log(chalk3.dim(`Uploading to ${host}...`));
+  const originalSize = JSON.stringify(artifact).length;
+  const compressedSize = body.length;
+  const ratio = ((1 - compressedSize / originalSize) * 100).toFixed(0);
+  console.log(chalk3.dim(`Uploading to ${host}... (${(compressedSize / 1024).toFixed(0)} KB, ${ratio}% smaller)`));
   try {
     const response = await fetch(url, {
       method: "POST",
       headers: {
         "Content-Type": "application/json",
+        "Content-Encoding": contentEncoding,
         "X-Vibgrate-Timestamp": timestamp,
         "Authorization": `VibgrateDSN ${parsed.keyId}:${parsed.secret}`,
         "Connection": "close"
@@ -7795,98 +8054,6 @@ async function scanOssGovernance(rootDir, fileCache) {
   };
 }
 
-// src/utils/compact-evidence.ts
-var CATEGORY_PATTERNS = [
-  { category: "pricing", pattern: /price|pricing|billing|subscri|trial|credit|plan|tier|upgrade|premium|pro|enterprise/i },
-  { category: "auth", pattern: /sign[- ]?in|sign[- ]?up|log[- ]?in|log[- ]?out|auth|sso|oauth|password|register|invite|onboard/i },
-  { category: "dashboard", pattern: /dashboard|overview|home|main|summary|stats/i },
-  { category: "settings", pattern: /setting|config|preference|option|profile|account/i },
-  { category: "users", pattern: /user|member|team|role|permission|access|admin|owner/i },
-  { category: "integrations", pattern: /integrat|connect|webhook|api[- ]?key|sync|import|export/i },
-  { category: "reports", pattern: /report|analy|metric|chart|graph|insight|track/i },
-  { category: "workflows", pattern: /workflow|automat|schedule|trigger|action|job|task|pipeline/i },
-  { category: "projects", pattern: /project|workspace|organization|folder|repo/i },
-  { category: "navigation", pattern: /menu|nav|sidebar|header|footer|breadcrumb/i }
-];
-function compactUiPurpose(result, maxSamplesPerCategory = 3) {
-  const evidence = result.topEvidence;
-  const dependencies = evidence.filter((e) => e.kind === "dependency").map((e) => e.value).slice(0, 10);
-  const routes = dedupeRoutes(
-    evidence.filter((e) => e.kind === "route").map((e) => e.value)
-  ).slice(0, 15);
-  const textEvidence = evidence.filter(
-    (e) => e.kind !== "dependency" && e.kind !== "route" && e.kind !== "feature_flag"
-  );
-  const byCategory = /* @__PURE__ */ new Map();
-  const categoryCounts = {};
-  for (const item of textEvidence) {
-    const category = categorize(item.value);
-    if (!byCategory.has(category)) {
-      byCategory.set(category, /* @__PURE__ */ new Set());
-    }
-    const normalized = normalizeValue(item.value);
-    if (normalized.length >= 3) {
-      byCategory.get(category).add(normalized);
-    }
-  }
-  const samples = [];
-  for (const [category, values] of byCategory) {
-    const deduped = dedupeStrings([...values]);
-    categoryCounts[category] = deduped.length;
-    for (const value of deduped.slice(0, maxSamplesPerCategory)) {
-      samples.push({ kind: "text", value, category });
-    }
-  }
-  const featureFlags = evidence.filter((e) => e.kind === "feature_flag");
-  if (featureFlags.length > 0) {
-    categoryCounts["feature_flags"] = featureFlags.length;
-    samples.push({ kind: "feature_flag", value: "feature flags detected", category: "feature_flags" });
-  }
-  return {
-    samples,
-    categoryCounts,
-    originalCount: evidence.length,
-    dependencies,
-    routes,
-    detectedFrameworks: result.detectedFrameworks
-  };
-}
-function categorize(value) {
-  for (const { category, pattern } of CATEGORY_PATTERNS) {
-    if (pattern.test(value)) return category;
-  }
-  return "general";
-}
-function normalizeValue(value) {
-  return value.toLowerCase().replace(/[^a-z0-9\s-]/g, " ").replace(/\s+/g, " ").trim().slice(0, 60);
-}
-function dedupeStrings(values) {
-  const sorted = values.sort((a, b) => b.length - a.length);
-  const kept = [];
-  for (const value of sorted) {
-    const isDupe = kept.some((k) => {
-      const stem = value.slice(0, 6);
-      return k.startsWith(stem) || k.includes(value) || value.includes(k);
-    });
-    if (!isDupe) {
-      kept.push(value);
-    }
-  }
-  return kept;
-}
-function dedupeRoutes(routes) {
-  const seen = /* @__PURE__ */ new Set();
-  const result = [];
-  for (const route of routes) {
-    const normalized = route.replace(/:[a-z_]+/gi, ":param").replace(/\[\[*\.*\.*[a-z_]+\]*\]/gi, ":param").replace(/\/+$/, "").toLowerCase();
-    if (!seen.has(normalized)) {
-      seen.add(normalized);
-      result.push(route);
-    }
-  }
-  return result;
-}
-
 // src/utils/tool-installer.ts
 import { spawn as spawn5 } from "child_process";
 import chalk5 from "chalk";
@@ -8836,7 +9003,7 @@ async function autoPush(artifact, rootDir, opts) {
     if (opts.strict) process.exit(1);
     return;
   }
-  const body = JSON.stringify(artifact);
+  const { body, contentEncoding } = await prepareCompressedUpload(artifact);
   const timestamp = String(Date.now());
   let host = parsed.host;
   if (opts.region) {
@@ -8849,12 +9016,16 @@ async function autoPush(artifact, rootDir, opts) {
     }
   }
   const url = `${parsed.scheme}://${host}/v1/ingest/scan`;
-  console.log(chalk6.dim(`Uploading to ${host}...`));
+  const originalSize = JSON.stringify(artifact).length;
+  const compressedSize = body.length;
+  const ratio = ((1 - compressedSize / originalSize) * 100).toFixed(0);
+  console.log(chalk6.dim(`Uploading to ${host}... (${(compressedSize / 1024).toFixed(0)} KB, ${ratio}% smaller)`));
   try {
     const response = await fetch(url, {
       method: "POST",
       headers: {
         "Content-Type": "application/json",
+        "Content-Encoding": contentEncoding,
         "X-Vibgrate-Timestamp": timestamp,
         "Authorization": `VibgrateDSN ${parsed.keyId}:${parsed.secret}`,
         "Connection": "close"

package/dist/{chunk-VGZRUFB4.js → chunk-IHDUX5MC.js}

@@ -1,6 +1,6 @@
 import {
   runScan
-} from "./chunk-XDZGC6KJ.js";
+} from "./chunk-DMYMJUQP.js";
 import {
   writeJsonFile
 } from "./chunk-TBE6NQ5Z.js";

package/dist/cli.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import {
   baselineCommand
-} from "./chunk-VGZRUFB4.js";
+} from "./chunk-IHDUX5MC.js";
 import {
   VERSION,
   dsnCommand,
@@ -10,7 +10,7 @@ import {
   pushCommand,
   scanCommand,
   writeDefaultConfig
-} from "./chunk-XDZGC6KJ.js";
+} from "./chunk-DMYMJUQP.js";
 import {
   ensureDir,
   pathExists,
@@ -39,7 +39,7 @@ var initCommand = new Command("init").description("Initialize vibgrate in a proj
     console.log(chalk.green("\u2714") + ` Created ${chalk.bold("vibgrate.config.ts")}`);
   }
   if (opts.baseline) {
-    const { runBaseline } = await import("./baseline-WRLXEJGA.js");
+    const { runBaseline } = await import("./baseline-IEG2JITU.js");
     await runBaseline(rootDir);
   }
   console.log("");

package/dist/index.js

@@ -5,7 +5,7 @@ import {
   formatText,
   generateFindings,
   runScan
-} from "./chunk-XDZGC6KJ.js";
+} from "./chunk-DMYMJUQP.js";
 import "./chunk-TBE6NQ5Z.js";
 export {
   computeDriftScore,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vibgrate/cli",
-  "version": "1.0.65",
+  "version": "1.0.66",
   "description": "CLI for measuring upgrade drift across Node, .NET, Python & Java projects",
   "type": "module",
   "bin": {