@kylewadegrove/cutline-mcp-cli 0.4.2 → 0.5.0

package/dist/servers/chunk-PU7TL6S3.js

@@ -0,0 +1,91 @@
+// ../mcp/dist/mcp/src/shared/firestore-retry.js
+var TRANSIENT_GRPC_CODES = /* @__PURE__ */ new Set([
+  4,
+  // DEADLINE_EXCEEDED
+  8,
+  // RESOURCE_EXHAUSTED
+  10,
+  // ABORTED (transaction contention)
+  13,
+  // INTERNAL
+  14
+  // UNAVAILABLE
+]);
+var TRANSIENT_MESSAGE_PATTERNS = [
+  "UNAVAILABLE",
+  "DEADLINE_EXCEEDED",
+  "ABORTED",
+  "INTERNAL",
+  "RESOURCE_EXHAUSTED",
+  "ECONNRESET",
+  "ETIMEDOUT",
+  "socket hang up",
+  "fetch failed",
+  "RST_STREAM",
+  "Connection reset"
+];
+function isTransientFirestoreError(err) {
+  if (!err || typeof err !== "object")
+    return false;
+  const e = err;
+  if (typeof e.code === "number" && TRANSIENT_GRPC_CODES.has(e.code)) {
+    return true;
+  }
+  const msg = String(e.message ?? "");
+  return TRANSIENT_MESSAGE_PATTERNS.some((pat) => msg.includes(pat));
+}
+var DEFAULTS = {
+  maxRetries: 3,
+  baseDelayMs: 200,
+  jitter: true,
+  operationName: "firestore_write"
+};
+async function firestoreRetry(fn, options = {}) {
+  const opts = { ...DEFAULTS, ...options };
+  let lastErr;
+  for (let attempt = 0; attempt <= opts.maxRetries; attempt++) {
+    try {
+      return await fn();
+    } catch (err) {
+      lastErr = err;
+      if (!isTransientFirestoreError(err)) {
+        throw err;
+      }
+      if (attempt >= opts.maxRetries) {
+        auditLog("firestore_retry_exhausted", opts.operationName, {
+          attempts: attempt + 1,
+          error: String(err?.message ?? err).slice(0, 200)
+        });
+        throw err;
+      }
+      const baseDelay = opts.baseDelayMs * Math.pow(2, attempt);
+      const delay = opts.jitter ? baseDelay + Math.random() * baseDelay : baseDelay;
+      auditLog("firestore_retry", opts.operationName, {
+        attempt: attempt + 1,
+        operation: opts.operationName,
+        delay_ms: Math.round(delay),
+        error: String(err?.message ?? err).slice(0, 200)
+      });
+      await sleep(delay);
+    }
+  }
+  throw lastErr;
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function auditLog(eventType, operation, data) {
+  console.error(JSON.stringify({
+    audit: true,
+    severity: "WARNING",
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    eventType,
+    resourceType: "firestore",
+    resourceId: operation,
+    data
+  }));
+}
+
+export {
+  firestoreRetry
+};

package/dist/servers/chunk-TGSEURMN.js

@@ -0,0 +1,46 @@
+// ../mcp/dist/mcp/src/context-graph/score-history.js
+import { getApps, getApp } from "firebase-admin/app";
+import { getFirestore, Timestamp } from "firebase-admin/firestore";
+function db() {
+  const app = getApps().length > 0 ? getApp() : void 0;
+  if (!app)
+    throw new Error("Firebase not initialized");
+  return getFirestore(app);
+}
+async function recordScoreSnapshot(productId, metrics, event, eventDetail) {
+  try {
+    const firestore = db();
+    const now = Timestamp.now();
+    const snapshot = {
+      engineering_readiness_pct: Math.round(metrics.engineering_readiness_pct ?? 0),
+      security_readiness_pct: Math.round(metrics.security_readiness_pct ?? 0),
+      reliability_readiness_pct: Math.round(metrics.reliability_readiness_pct ?? 0),
+      scalability_readiness_pct: Math.round(metrics.scalability_readiness_pct ?? 0),
+      nfr_coverage_pct: Math.round((metrics.nfr_coverage?.overall ?? 0) * 100),
+      speedup_factor: metrics.time_estimate?.speedup_factor ?? 1,
+      event,
+      ...eventDetail ? { event_detail: eventDetail } : {},
+      timestamp: now
+    };
+    const historyRef = firestore.collection("context_graph").doc(productId).collection("score_history").doc();
+    await historyRef.set(snapshot);
+    const jobRef = firestore.collection("premortem_jobs").doc(productId);
+    const jobSnap = await jobRef.get();
+    if (jobSnap.exists) {
+      const prefix = "result.decision.productionalization_feasibility";
+      await jobRef.update({
+        [`${prefix}.engineering_readiness_pct`]: snapshot.engineering_readiness_pct,
+        [`${prefix}.security_readiness_pct`]: snapshot.security_readiness_pct,
+        [`${prefix}.reliability_readiness_pct`]: snapshot.reliability_readiness_pct,
+        [`${prefix}.scalability_readiness_pct`]: snapshot.scalability_readiness_pct,
+        [`${prefix}.nfr_coverage_pct`]: snapshot.nfr_coverage_pct
+      });
+    }
+  } catch (err) {
+    console.error("[score-history] Failed to record snapshot:", err.message);
+  }
+}
+
+export {
+  recordScoreSnapshot
+};