@vibecheck-ai/mcp 24.6.8 → 24.6.11

package/dist/dist-JUOVMQEA.js

@@ -0,0 +1,9 @@
+import { createRequire } from 'module';
+import { fileURLToPath } from 'url';
+import { dirname } from 'path';
+export { VERSION, evolve, extractCoEdits, extractSequences, getBoostedFiles, getOutcomeBoost, getSequentialFiles, loadLearned, loadLearnedOrEvolveIfStale, readProvenance, recordFeedback } from './chunk-J52EUKKW.js';
+import './chunk-YWUMPN4Z.js';
+
+createRequire(import.meta.url);
+const __filename$1 = fileURLToPath(import.meta.url);
+dirname(__filename$1);

package/dist/dist-NXITTS32-O3XLWR6T.js

@@ -0,0 +1,386 @@
+import { createRequire } from 'module';
+import { fileURLToPath } from 'url';
+import * as path from 'path';
+import { dirname } from 'path';
+import './chunk-YWUMPN4Z.js';
+import { AsyncLocalStorage } from 'async_hooks';
+import { randomUUID } from 'crypto';
+import * as fs from 'fs';
+
+createRequire(import.meta.url);
+const __filename$1 = fileURLToPath(import.meta.url);
+dirname(__filename$1);
+var DEFAULT_OPTS = {
+  tracePath: ".vibecheck/nexus/runtime.jsonl",
+  flushEveryN: 16,
+  flushIntervalMs: 1e3,
+  rotateAtBytes: 64 * 1024 * 1024
+};
+var TraceRecorder = class {
+  opts;
+  buffer = [];
+  timer;
+  closed = false;
+  constructor(opts = {}) {
+    this.opts = {
+      ...DEFAULT_OPTS,
+      ...opts,
+      tracePath: opts.tracePath ?? DEFAULT_OPTS.tracePath
+    };
+    this.ensureParentDir();
+    this.scheduleFlush();
+  }
+  /** Enqueue an event; flushes synchronously when the batch is full. */
+  record(event) {
+    if (this.closed) return;
+    this.buffer.push(event);
+    if (this.buffer.length >= this.opts.flushEveryN) {
+      this.flush();
+    }
+  }
+  /** Write the buffered events to disk. Safe to call repeatedly. */
+  flush() {
+    if (this.buffer.length === 0) return;
+    const lines = this.buffer.map((e) => JSON.stringify(e)).join("\n") + "\n";
+    this.buffer = [];
+    try {
+      this.rotateIfOversized();
+      fs.appendFileSync(this.opts.tracePath, lines, { encoding: "utf-8" });
+    } catch {
+    }
+  }
+  /** Flush and stop the interval timer. Idempotent. */
+  close() {
+    if (this.closed) return;
+    this.closed = true;
+    if (this.timer) {
+      clearInterval(this.timer);
+      this.timer = void 0;
+    }
+    this.flush();
+  }
+  /** Path to the active trace file — handy for the merger. */
+  tracePath() {
+    return this.opts.tracePath;
+  }
+  scheduleFlush() {
+    this.timer = setInterval(() => this.flush(), this.opts.flushIntervalMs);
+    this.timer.unref?.();
+  }
+  ensureParentDir() {
+    const dir = path.dirname(this.opts.tracePath);
+    if (dir) {
+      try {
+        fs.mkdirSync(dir, { recursive: true });
+      } catch {
+      }
+    }
+  }
+  rotateIfOversized() {
+    if (this.opts.rotateAtBytes <= 0) return;
+    let size = 0;
+    try {
+      size = fs.statSync(this.opts.tracePath).size;
+    } catch {
+      return;
+    }
+    if (size < this.opts.rotateAtBytes) return;
+    const archive = `${this.opts.tracePath}.1`;
+    try {
+      fs.rmSync(archive, { force: true });
+      fs.renameSync(this.opts.tracePath, archive);
+    } catch {
+    }
+  }
+};
+var storage = new AsyncLocalStorage();
+var NexusTracer = class {
+  recorder = null;
+  opts;
+  running = false;
+  constructor(opts = {}) {
+    this.opts = opts;
+  }
+  /**
+   * Start the tracer. Creates the JSONL file handle through the recorder.
+   * Safe to call twice — second call is a no-op.
+   */
+  start() {
+    if (this.running) return;
+    this.recorder = new TraceRecorder(this.opts);
+    this.running = true;
+  }
+  /** Stop the tracer and flush buffered events. */
+  stop() {
+    if (!this.running) return;
+    this.running = false;
+    this.recorder?.close();
+    this.recorder = null;
+  }
+  /** Whether the tracer is recording. */
+  isRunning() {
+    return this.running;
+  }
+  /**
+   * Run `fn` inside a freshly-created trace context. Every nested
+   * `recordCall` invocation below this point inherits the same `traceId`.
+   */
+  withTrace(label, fn) {
+    const ctx = { traceId: randomUUID(), label };
+    return storage.run(ctx, fn);
+  }
+  /**
+   * Record a single call. Captures start/end timestamps, duration,
+   * and errored status, then writes a `TraceEvent` to the recorder.
+   */
+  recordCall(args, fn) {
+    if (!this.running || !this.recorder) return fn();
+    if (!this.shouldSample()) return fn();
+    const callId = randomUUID();
+    const startedAt = /* @__PURE__ */ new Date();
+    const parent = storage.getStore();
+    const ctx = parent ? { ...parent, currentCallId: callId } : { traceId: randomUUID(), currentCallId: callId, label: args.label };
+    const finish = (errored, durationMs) => {
+      const event = {
+        v: 1,
+        symbolId: args.symbolId,
+        startedAt: startedAt.toISOString(),
+        durationMs,
+        errored,
+        traceId: ctx.traceId,
+        callId,
+        ...parent?.currentCallId ? { parentCallId: parent.currentCallId } : {}
+      };
+      this.recorder?.record(event);
+    };
+    const started = performanceNow();
+    let result;
+    try {
+      result = storage.run(ctx, fn);
+    } catch (err) {
+      finish(true, performanceNow() - started);
+      throw err;
+    }
+    if (isPromise(result)) {
+      return result.then(
+        (value) => {
+          finish(false, performanceNow() - started);
+          return value;
+        },
+        (err) => {
+          finish(true, performanceNow() - started);
+          throw err;
+        }
+      );
+    }
+    finish(false, performanceNow() - started);
+    return result;
+  }
+  /**
+   * Return an instrumented wrapper around `fn`. The returned function has
+   * the same arity and name as the original so consumers that inspect those
+   * (e.g. some router middlewares) see no change.
+   */
+  wrap(fn, symbolId) {
+    const tracer = this;
+    const resolvedId = symbolId ?? fn.name ?? this.opts.defaultSymbolId ?? "anonymous";
+    const wrapped = function wrapped2(...args) {
+      return tracer.recordCall({ symbolId: resolvedId }, () => fn.apply(this, args));
+    };
+    try {
+      Object.defineProperty(wrapped, "length", { value: fn.length, configurable: true });
+      Object.defineProperty(wrapped, "name", {
+        value: fn.name || resolvedId,
+        configurable: true
+      });
+    } catch {
+    }
+    return wrapped;
+  }
+  /** Reveal the active recorder path so the merger can find it. */
+  tracePath() {
+    return this.recorder?.tracePath() ?? null;
+  }
+  shouldSample() {
+    const rate = this.opts.sampleRate ?? 1;
+    if (rate >= 1) return true;
+    if (rate <= 0) return false;
+    return Math.random() < rate;
+  }
+};
+var singleton = null;
+function getTracer(opts) {
+  if (!singleton) singleton = new NexusTracer(opts);
+  return singleton;
+}
+function isPromise(v) {
+  return typeof v === "object" && v !== null && typeof v.then === "function";
+}
+function performanceNow() {
+  if (typeof process !== "undefined" && process.hrtime?.bigint) {
+    return Number(process.hrtime.bigint() / 1000000n);
+  }
+  return Date.now();
+}
+function readOptsFromEnv() {
+  const opts = {};
+  const envPath = process.env["NEXUS_TRACE_PATH"];
+  if (envPath) opts.tracePath = envPath;
+  const envRate = process.env["NEXUS_SAMPLE_RATE"];
+  if (envRate) {
+    const r = Number(envRate);
+    if (Number.isFinite(r) && r >= 0 && r <= 1) opts.sampleRate = r;
+  }
+  const envRotate = process.env["NEXUS_ROTATE_BYTES"];
+  if (envRotate) {
+    const n = Number(envRotate);
+    if (Number.isFinite(n) && n >= 0) opts.rotateAtBytes = n;
+  }
+  return opts;
+}
+function bootstrap() {
+  const tracer = getTracer(readOptsFromEnv());
+  tracer.start();
+  const flushAndExit = () => {
+    try {
+      tracer.stop();
+    } catch {
+    }
+  };
+  process.on("exit", flushAndExit);
+  process.on("SIGINT", flushAndExit);
+  process.on("SIGTERM", flushAndExit);
+  process.on("uncaughtException", (err) => {
+    flushAndExit();
+    throw err;
+  });
+  process.on("unhandledRejection", flushAndExit);
+}
+bootstrap();
+var OTEL_STATUS_ERROR = 2;
+var OtelExporter = class {
+  tracer;
+  resolve;
+  constructor(opts) {
+    this.tracer = opts.tracer;
+    this.resolve = opts.resolveSymbolId ?? defaultResolveSymbolId;
+  }
+  /** Fold one completed OTEL span into the Nexus trace stream. */
+  onSpan(span) {
+    if (!this.tracer.isRunning()) return;
+    const recorder = this.tracer.recorder;
+    if (!recorder) return;
+    const sc = span.spanContext();
+    const startedAt = new Date(toMillis(span.startTime)).toISOString();
+    const durationMs = span.duration !== void 0 ? toMillis(span.duration) : void 0;
+    const errored = span.status?.code === OTEL_STATUS_ERROR;
+    const event = {
+      v: 1,
+      symbolId: this.resolve(span),
+      startedAt,
+      ...durationMs !== void 0 ? { durationMs } : {},
+      ...errored ? { errored: true } : {},
+      traceId: sc.traceId,
+      callId: sc.spanId,
+      ...span.parentSpanId ? { parentCallId: span.parentSpanId } : {}
+    };
+    recorder.record(event);
+  }
+};
+function defaultResolveSymbolId(span) {
+  const attrs = span.attributes ?? {};
+  const direct = attrs["nexus.symbolId"];
+  if (typeof direct === "string" && direct.length > 0) return direct;
+  const file = attrs["code.filepath"];
+  const fn = attrs["code.function"];
+  if (typeof file === "string" && typeof fn === "string") {
+    return `${file}#${fn}`;
+  }
+  return span.name;
+}
+function toMillis(time) {
+  if (typeof time === "number") return time;
+  if (Array.isArray(time)) {
+    const [s, ns] = time;
+    return s * 1e3 + Math.floor(ns / 1e6);
+  }
+  if (time && typeof time === "object") {
+    return time.seconds * 1e3 + Math.floor(time.nanos / 1e6);
+  }
+  return 0;
+}
+function loadTraces(tracePath) {
+  let content;
+  try {
+    content = fs.readFileSync(tracePath, { encoding: "utf-8" });
+  } catch {
+    return [];
+  }
+  const events = [];
+  for (const raw of content.split("\n")) {
+    const line = raw.trim();
+    if (!line) continue;
+    try {
+      const parsed = JSON.parse(line);
+      if (parsed && parsed.v === 1 && typeof parsed.symbolId === "string") {
+        events.push(parsed);
+      }
+    } catch {
+    }
+  }
+  return events;
+}
+function mergeRuntimeTraces(events) {
+  const groups = /* @__PURE__ */ new Map();
+  for (const ev of events) {
+    const list = groups.get(ev.symbolId);
+    if (list) list.push(ev);
+    else groups.set(ev.symbolId, [ev]);
+  }
+  const out = [];
+  for (const [symbolId, rows] of groups) {
+    let errorCount = 0;
+    let totalLatency = 0;
+    let latencyCount = 0;
+    let lastSeen;
+    const durations = [];
+    for (const r of rows) {
+      if (r.errored) errorCount += 1;
+      if (typeof r.durationMs === "number") {
+        totalLatency += r.durationMs;
+        latencyCount += 1;
+        durations.push(r.durationMs);
+      }
+      if (!lastSeen || r.startedAt > lastSeen) lastSeen = r.startedAt;
+    }
+    const trace = {
+      symbolId,
+      callCount: rows.length,
+      ...latencyCount > 0 ? { totalLatencyMs: round(totalLatency) } : {},
+      ...durations.length > 0 ? { p50Ms: round(percentile(durations, 0.5)) } : {},
+      ...durations.length > 0 ? { p95Ms: round(percentile(durations, 0.95)) } : {},
+      ...errorCount > 0 ? { errorCount } : {},
+      ...lastSeen ? { lastSeenAt: lastSeen } : {}
+    };
+    out.push(trace);
+  }
+  out.sort((a, b) => a.symbolId.localeCompare(b.symbolId));
+  return out;
+}
+function loadAndMerge(tracePath) {
+  return mergeRuntimeTraces(loadTraces(tracePath));
+}
+function percentile(values, q) {
+  if (values.length === 0) return 0;
+  const sorted = [...values].sort((a, b) => a - b);
+  const idx = Math.min(
+    sorted.length - 1,
+    Math.max(0, Math.floor(q * (sorted.length - 1)))
+  );
+  return sorted[idx] ?? 0;
+}
+function round(n) {
+  return Math.round(n * 100) / 100;
+}
+
+export { NexusTracer, OtelExporter, TraceRecorder, bootstrap as bootstrapTracer, getTracer, loadAndMerge, loadTraces, mergeRuntimeTraces };

package/dist/dist-OUJKMVTB.js

@@ -0,0 +1,22 @@
+import { createRequire } from 'module';
+import { fileURLToPath } from 'url';
+import { dirname } from 'path';
+export { CircuitBreaker, ENGINE_FOCUS_PRESETS, EngineRegistry, EnvLoader, FakeFeaturesEngine, IncompleteImplEngine, OutcomeVerificationEngine, PerformanceAntipatternEngine, RULE_AUTOFIX_SAFETY_BY_ID, RULE_MATURITY_BY_ID, RULE_TRUST_IMPACT_BY_ID, RuntimeProbeEngine, SCAN_ENGINE_FOCUS_PRESET_NAMES, SecurityPatternEngine, TruthpackEnvIndex, TypeContractEngine, VIBECHECK_DEFAULT_ENGINE_IDS, accessibilityEngine, autofixSafetyForRule, backendEngine, buildCiSummaryJson, buildRiskClusters, buildShipBlockers, categoryIcons, computeTrustScore, configurationEngine, createDefaultRegistry, diffScores, documentationEngine, engineTogglesAllowOnly, estimateBlastRadius, findUncalledExportedFunctions, formatCiSummaryMarkdown, formatCiSummaryPlainLines, formatFindings, formatSummary, formatTraceAsJson, formatTraceForTerminal, formatTrustScoreMarkdown, generateVerdict, icons, infrastructureEngine, isTestLikeScanPath, isVibecheckFinding, loadTruthpack, maturityTierForRule, observabilityEngine, parseCallSites, performanceEngine, resilienceEngine, runGhostTrace, runPolish, scan, securityEngine, seoEngine, toCanonicalFinding, toCanonicalFindingFromGuardrail, toCanonicalFindingFromLegacyFinding, toCanonicalFindingFromMissionFinding, toCanonicalFindingFromPolish, toCanonicalFindingFromReport, toCanonicalFindingFromScanApi, toCanonicalFindingFromScanFinding, toCanonicalFindings, toSarif, trustImpactForRule, trustPenaltyScaleForFinding, truthpackToRouteIndex } from './chunk-RNFMO5GH.js';
+export { FrameworkPackEngine } from './chunk-MUP4JXOF.js';
+export { LogicGapEngine } from './chunk-DDTUTWRY.js';
+export { ErrorHandlingEngine } from './chunk-QFDZMUGO.js';
+export { BaseEngine } from './chunk-RR5ETBSV.js';
+export { computeWorkspaceFingerprint } from './chunk-FGMVY5QW.js';
+export { EngineError, EngineErrorCode, PhantomDepEngine, createContext, extractPythonPypiImports, getLanguageProfile, goLanguageProfile, isEngineError, javascriptLanguageProfile, pythonLanguageProfile, withEngineErrorHandling } from './chunk-G3FQJC2H.js';
+export { extractJavaScriptImportSpecifiersFlat, extractJavaScriptNpmImports, extractPackageName, isNodeBuiltin, isRelativeOrAlias } from './chunk-NR36RTVO.js';
+export { APITruthEngine } from './chunk-JZSHXEYP.js';
+export { EnvVarEngine } from './chunk-QYXENOVK.js';
+export { GhostRouteEngine } from './chunk-LQSBUKYZ.js';
+export { CredentialsEngine } from './chunk-5DADZJ3D.js';
+export { SecurityEngine } from './chunk-43XAAYST.js';
+export { VersionHallucinationEngine } from './chunk-F34MHA6A.js';
+import './chunk-YWUMPN4Z.js';
+
+createRequire(import.meta.url);
+const __filename$1 = fileURLToPath(import.meta.url);
+dirname(__filename$1);

package/dist/fingerprint-NOJ7TDB6-K6SB7LCZ.js

@@ -0,0 +1,9 @@
+import { createRequire } from 'module';
+import { fileURLToPath } from 'url';
+import { dirname } from 'path';
+export { computeWorkspaceFingerprint } from './chunk-FGMVY5QW.js';
+import './chunk-YWUMPN4Z.js';
+
+createRequire(import.meta.url);
+const __filename$1 = fileURLToPath(import.meta.url);
+dirname(__filename$1);