@vibekiln/cutline-mcp-cli 0.1.0

package/dist/servers/chunk-UBBAYTW3.js

@@ -0,0 +1,946 @@
+// ../mcp/dist/mcp/src/context-graph/conflict-taxonomy.js
+var CONFLICT_TAXONOMY = [
+  {
+    tag_a: ["encryption", "e2e", "homomorphic", "zero-trust", "zero_trust", "tls"],
+    tag_b: ["low-latency", "real-time", "realtime", "sub-second", "fast-response", "sub-10ms"],
+    tension: "Security vs Latency"
+  },
+  {
+    tag_a: ["heavy-computation", "ml-inference", "ai", "llm", "deep-learning", "gpu"],
+    tag_b: ["low-cost", "free-tier", "minimal-cogs", "cheap", "budget", "cost-sensitive"],
+    tension: "Compute Cost vs AI/ML Features"
+  },
+  {
+    tag_a: ["offline-first", "local-storage", "edge-compute", "local-only"],
+    tag_b: ["real-time-sync", "strong-consistency", "centralized", "cloud-first", "server-authoritative"],
+    tension: "Offline Availability vs Real-time Consistency"
+  },
+  {
+    tag_a: ["privacy", "gdpr", "data-minimization", "anonymization", "pii-protection"],
+    tag_b: ["personalization", "analytics", "tracking", "recommendation", "targeting", "behavioral"],
+    tension: "Privacy vs Personalization"
+  },
+  {
+    tag_a: ["simplicity", "minimal-ui", "frictionless", "one-click", "low-friction"],
+    tag_b: ["compliance", "audit", "verification", "multi-factor", "mfa", "approval-flow", "kyc"],
+    tension: "UX Simplicity vs Compliance Requirements"
+  },
+  {
+    tag_a: ["backward-compatible", "legacy-support", "stable-api", "no-breaking-changes"],
+    tag_b: ["breaking-change", "greenfield", "rewrite", "v2-redesign", "clean-slate"],
+    tension: "Backward Compatibility vs Clean Architecture"
+  },
+  {
+    tag_a: ["soc2", "hipaa", "audit-trail", "full-logging", "traceability", "retention"],
+    tag_b: ["data-minimization", "ephemeral", "no-logs", "privacy-by-design", "right-to-delete"],
+    tension: "Audit Compliance vs Data Minimization"
+  },
+  {
+    tag_a: ["scalability", "horizontal-scale", "distributed", "microservice", "high-throughput"],
+    tag_b: ["simplicity", "monolith", "single-deploy", "minimal-infra", "low-ops"],
+    tension: "Scalability vs Operational Simplicity"
+  },
+  {
+    tag_a: ["open-source", "vendor-neutral", "self-hosted", "portable"],
+    tag_b: ["managed-service", "vendor-lock-in", "saas-dependency", "proprietary"],
+    tension: "Vendor Independence vs Managed Convenience"
+  },
+  {
+    tag_a: ["security", "hardened", "strict-cors", "least-privilege", "sandboxed"],
+    tag_b: ["developer-experience", "fast-iteration", "permissive", "hot-reload", "no-auth-dev"],
+    tension: "Security Posture vs Developer Velocity"
+  }
+];
+var ALL_TAXONOMY_TAGS = /* @__PURE__ */ new Set();
+for (const pair of CONFLICT_TAXONOMY) {
+  for (const t of pair.tag_a)
+    ALL_TAXONOMY_TAGS.add(t);
+  for (const t of pair.tag_b)
+    ALL_TAXONOMY_TAGS.add(t);
+}
+function getRelevantTags(c) {
+  const tags = /* @__PURE__ */ new Set();
+  for (const k of c.keywords) {
+    const lk = k.toLowerCase();
+    if (ALL_TAXONOMY_TAGS.has(lk))
+      tags.add(lk);
+  }
+  const cat = String(c.category).toLowerCase();
+  if (ALL_TAXONOMY_TAGS.has(cat))
+    tags.add(cat);
+  const words = c.summary.toLowerCase().split(/[^a-z0-9-]+/).filter((w) => w.length > 2);
+  for (const w of words) {
+    if (ALL_TAXONOMY_TAGS.has(w))
+      tags.add(w);
+  }
+  return tags;
+}
+function findSemanticTagConflict(a, b) {
+  const tagsA = getRelevantTags(a);
+  const tagsB = getRelevantTags(b);
+  if (tagsA.size === 0 || tagsB.size === 0)
+    return null;
+  for (const pair of CONFLICT_TAXONOMY) {
+    const aMatchesSideA = pair.tag_a.some((t) => tagsA.has(t));
+    const bMatchesSideB = pair.tag_b.some((t) => tagsB.has(t));
+    if (aMatchesSideA && bMatchesSideB)
+      return pair;
+    const aMatchesSideB = pair.tag_b.some((t) => tagsA.has(t));
+    const bMatchesSideA = pair.tag_a.some((t) => tagsB.has(t));
+    if (aMatchesSideB && bMatchesSideA)
+      return pair;
+  }
+  return null;
+}
+function thresholdsConflict(a, b) {
+  const aVal = Array.isArray(a.value) ? a.value[1] : a.value;
+  const bVal = Array.isArray(b.value) ? b.value[0] : b.value;
+  if ((a.operator === "<" || a.operator === "<=") && (b.operator === ">" || b.operator === ">=")) {
+    return aVal <= bVal;
+  }
+  if ((a.operator === ">" || a.operator === ">=") && (b.operator === "<" || b.operator === "<=")) {
+    return bVal <= aVal;
+  }
+  return false;
+}
+function detectConstraintConflicts(entityId, constraints) {
+  const conflicts = [];
+  for (let i = 0; i < constraints.length; i++) {
+    for (let j = i + 1; j < constraints.length; j++) {
+      const a = constraints[i];
+      const b = constraints[j];
+      if (a.threshold && b.threshold && a.threshold.metric === b.threshold.metric) {
+        if (thresholdsConflict(a.threshold, b.threshold)) {
+          conflicts.push({
+            constraint_a: a,
+            constraint_b: b,
+            entity_id: entityId,
+            conflict_type: "threshold",
+            description: `Conflicting thresholds on "${a.threshold.metric}": ${a.threshold.operator} ${a.threshold.value}${a.threshold.unit ? " " + a.threshold.unit : ""} vs ${b.threshold.operator} ${b.threshold.value}${b.threshold.unit ? " " + b.threshold.unit : ""}`
+          });
+          continue;
+        }
+      }
+      if (a.scope && b.scope && a.scope !== b.scope) {
+        const shared = a.keywords.filter((k) => b.keywords.includes(k));
+        if (shared.length >= 2) {
+          conflicts.push({
+            constraint_a: a,
+            constraint_b: b,
+            entity_id: entityId,
+            conflict_type: "scope",
+            description: `Scope conflict: "${a.summary.slice(0, 60)}" is ${a.scope} but "${b.summary.slice(0, 60)}" is ${b.scope}`
+          });
+          continue;
+        }
+      }
+      const pair = findSemanticTagConflict(a, b);
+      if (pair) {
+        conflicts.push({
+          constraint_a: a,
+          constraint_b: b,
+          entity_id: entityId,
+          conflict_type: "semantic_tag",
+          tension: pair.tension,
+          description: `Constraint collision (${pair.tension}): "${a.summary.slice(0, 60)}" conflicts with "${b.summary.slice(0, 60)}"`
+        });
+      }
+    }
+  }
+  return conflicts;
+}
+
+// ../mcp/dist/mcp/src/context-graph/graph-traverser.js
+var GraphTraverser = class {
+  entities = /* @__PURE__ */ new Map();
+  constraints = /* @__PURE__ */ new Map();
+  bindings = [];
+  // adjacency: nodeId -> outgoing edges
+  outgoing = /* @__PURE__ */ new Map();
+  // reverse adjacency: nodeId -> incoming edges
+  incoming = /* @__PURE__ */ new Map();
+  constructor(entities, edges, constraintNodes, bindings) {
+    for (const e of entities)
+      this.entities.set(e.id, e);
+    for (const c of constraintNodes)
+      this.constraints.set(c.id, c);
+    this.bindings = bindings;
+    for (const edge of edges) {
+      const out = this.outgoing.get(edge.source_id) ?? [];
+      out.push({ targetId: edge.target_id, edge });
+      this.outgoing.set(edge.source_id, out);
+      const inc = this.incoming.get(edge.target_id) ?? [];
+      inc.push({ targetId: edge.source_id, edge });
+      this.incoming.set(edge.target_id, inc);
+    }
+  }
+  // ═════════════════════════════════════════════════════════════════════════════
+  // LOOKUP
+  // ═════════════════════════════════════════════════════════════════════════════
+  getEntity(id) {
+    return this.entities.get(id);
+  }
+  getConstraint(id) {
+    return this.constraints.get(id);
+  }
+  /** Find entities whose file_patterns match the given file path. */
+  findEntitiesByFilePath(filePath) {
+    const normalizedPath = filePath.replace(/\\/g, "/");
+    const matchedEntityIds = /* @__PURE__ */ new Set();
+    for (const binding of this.bindings) {
+      for (const pattern of binding.file_patterns) {
+        if (globMatch(normalizedPath, pattern)) {
+          matchedEntityIds.add(binding.entity_id);
+          break;
+        }
+      }
+    }
+    return [...matchedEntityIds].map((id) => this.entities.get(id)).filter(Boolean);
+  }
+  /** Find entity by name (case-insensitive, checks aliases too). */
+  findEntityByName(name) {
+    const lower = name.toLowerCase();
+    for (const entity of this.entities.values()) {
+      if (entity.name.toLowerCase() === lower)
+        return entity;
+      if (entity.aliases.some((a) => a.toLowerCase() === lower))
+        return entity;
+    }
+    return void 0;
+  }
+  // ═════════════════════════════════════════════════════════════════════════════
+  // SUBGRAPH EXTRACTION (BFS)
+  // ═════════════════════════════════════════════════════════════════════════════
+  /**
+   * Extract a localized subgraph rooted at `entityId`, traversing up to
+   * `maxDepth` hops along both outgoing and incoming edges.
+   * Collects all reachable entities and their attached constraints.
+   */
+  getSubgraph(entityId, maxDepth = 2) {
+    const rootEntity = this.entities.get(entityId);
+    if (!rootEntity)
+      return null;
+    const visitedEntities = /* @__PURE__ */ new Set();
+    const visitedConstraints = /* @__PURE__ */ new Set();
+    const collectedEdges = [];
+    const queue = [[entityId, 0]];
+    visitedEntities.add(entityId);
+    while (queue.length > 0) {
+      const [currentId, depth] = queue.shift();
+      const out = this.outgoing.get(currentId) ?? [];
+      for (const { targetId, edge } of out) {
+        collectedEdges.push(edge);
+        if (this.constraints.has(targetId)) {
+          visitedConstraints.add(targetId);
+        } else if (this.entities.has(targetId) && !visitedEntities.has(targetId)) {
+          visitedEntities.add(targetId);
+          if (depth + 1 <= maxDepth) {
+            queue.push([targetId, depth + 1]);
+          }
+        }
+      }
+      const inc = this.incoming.get(currentId) ?? [];
+      for (const { targetId: sourceId, edge } of inc) {
+        collectedEdges.push(edge);
+        if (this.constraints.has(sourceId)) {
+          visitedConstraints.add(sourceId);
+        } else if (this.entities.has(sourceId) && !visitedEntities.has(sourceId)) {
+          visitedEntities.add(sourceId);
+          if (depth + 1 <= maxDepth) {
+            queue.push([sourceId, depth + 1]);
+          }
+        }
+      }
+    }
+    const entities = [...visitedEntities].map((id) => this.entities.get(id)).filter(Boolean);
+    const constraints = [...visitedConstraints].map((id) => this.constraints.get(id)).filter(Boolean);
+    const propagated = this.propagateConstraints(entities, collectedEdges);
+    for (const c of propagated) {
+      if (!visitedConstraints.has(c.id)) {
+        constraints.push(c);
+      }
+    }
+    const conflicts = this.detectConflicts(entityId, constraints);
+    const uniqueEdges = deduplicateEdges(collectedEdges);
+    return {
+      target_entity: rootEntity,
+      entities,
+      constraints,
+      edges: uniqueEdges,
+      conflicts
+    };
+  }
+  // ═════════════════════════════════════════════════════════════════════════════
+  // NFR PROPAGATION
+  // ═════════════════════════════════════════════════════════════════════════════
+  /**
+   * Propagate NFRs downward through the graph.
+   *
+   * Rules:
+   *  - If a DataType is GOVERNED_BY a Constraint, any Component that HANDLES
+   *    that DataType inherits the constraint.
+   *  - If a Feature is BOUNDED_BY a Constraint, any Component that the Feature
+   *    REQUIRES inherits the constraint.
+   *
+   * Returns constraints that were inherited (not directly attached).
+   */
+  propagateConstraints(subgraphEntities, subgraphEdges) {
+    const inherited = [];
+    const entityIds = new Set(subgraphEntities.map((e) => e.id));
+    const handleEdges = subgraphEdges.filter((e) => e.edge_type === "HANDLES");
+    const requiresEdges = subgraphEdges.filter((e) => e.edge_type === "REQUIRES");
+    const governedByEdges = subgraphEdges.filter((e) => e.edge_type === "GOVERNED_BY");
+    const boundedByEdges = subgraphEdges.filter((e) => e.edge_type === "BOUNDED_BY");
+    for (const govEdge of governedByEdges) {
+      const constraint = this.constraints.get(govEdge.target_id);
+      if (!constraint)
+        continue;
+      for (const handleEdge of handleEdges) {
+        if (handleEdge.target_id === govEdge.source_id && entityIds.has(handleEdge.source_id)) {
+          inherited.push(constraint);
+        }
+      }
+    }
+    for (const boundEdge of boundedByEdges) {
+      const sourceEntity = this.entities.get(boundEdge.source_id);
+      if (!sourceEntity || sourceEntity.type !== "feature")
+        continue;
+      const constraint = this.constraints.get(boundEdge.target_id);
+      if (!constraint)
+        continue;
+      for (const reqEdge of requiresEdges) {
+        if (reqEdge.source_id === boundEdge.source_id && entityIds.has(reqEdge.target_id)) {
+          inherited.push(constraint);
+        }
+      }
+    }
+    const seen = /* @__PURE__ */ new Set();
+    return inherited.filter((c) => {
+      if (seen.has(c.id))
+        return false;
+      seen.add(c.id);
+      return true;
+    });
+  }
+  // ═════════════════════════════════════════════════════════════════════════════
+  // CONFLICT DETECTION
+  // ═════════════════════════════════════════════════════════════════════════════
+  /**
+   * Detect conflicting constraints on the same entity.
+   * Delegates to the standalone `detectConstraintConflicts()` which checks
+   * three heuristics: threshold, scope, and semantic-tag conflicts.
+   */
+  detectConflicts(entityId, constraints) {
+    return detectConstraintConflicts(entityId, constraints);
+  }
+  // ═════════════════════════════════════════════════════════════════════════════
+  // FULL GRAPH SUMMARY
+  // ═════════════════════════════════════════════════════════════════════════════
+  getSummary() {
+    return {
+      entities: [...this.entities.values()],
+      constraints: [...this.constraints.values()],
+      edges: getAllEdgesFromMaps(this.outgoing),
+      bindings: this.bindings
+    };
+  }
+};
+function globMatch(path, pattern) {
+  const regexStr = pattern.replace(/\./g, "\\.").replace(/\*\*/g, "{{GLOBSTAR}}").replace(/\*/g, "[^/]*").replace(/\{\{GLOBSTAR\}\}/g, ".*");
+  return new RegExp(`^${regexStr}$`, "i").test(path);
+}
+function deduplicateEdges(edges) {
+  const seen = /* @__PURE__ */ new Set();
+  return edges.filter((e) => {
+    if (seen.has(e.id))
+      return false;
+    seen.add(e.id);
+    return true;
+  });
+}
+function getAllEdgesFromMaps(outgoing) {
+  const edges = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const entries of outgoing.values()) {
+    for (const { edge } of entries) {
+      if (!seen.has(edge.id)) {
+        seen.add(edge.id);
+        edges.push(edge);
+      }
+    }
+  }
+  return edges;
+}
+
+// ../mcp/dist/mcp/src/context-graph/graph-metrics.js
+var CATEGORY_TO_BUCKET = {
+  security: "security",
+  performance: "performance",
+  infrastructure: "scalability",
+  scalability: "scalability",
+  architecture: "stability",
+  stability: "stability",
+  compliance: "compliance",
+  risk: "security",
+  accessibility: "compliance"
+};
+function toBucket(category) {
+  return CATEGORY_TO_BUCKET[category] ?? null;
+}
+function computeNfrCoverage(entities, edges, constraints) {
+  const featureEntities = entities.filter((e) => e.type === "feature");
+  if (featureEntities.length === 0) {
+    return { security: 0, performance: 0, scalability: 0, stability: 0, compliance: 0, overall: 0 };
+  }
+  const featureIds = new Set(featureEntities.map((e) => e.id));
+  const constraintMap = new Map(constraints.map((c) => [c.id, c]));
+  const coveredByBucket = {
+    security: /* @__PURE__ */ new Set(),
+    performance: /* @__PURE__ */ new Set(),
+    scalability: /* @__PURE__ */ new Set(),
+    stability: /* @__PURE__ */ new Set(),
+    compliance: /* @__PURE__ */ new Set()
+  };
+  for (const edge of edges) {
+    if (edge.edge_type !== "GOVERNED_BY" && edge.edge_type !== "BOUNDED_BY")
+      continue;
+    if (!featureIds.has(edge.source_id))
+      continue;
+    const constraint = constraintMap.get(edge.target_id);
+    if (!constraint)
+      continue;
+    const bucket = toBucket(constraint.category);
+    if (!bucket)
+      continue;
+    coveredByBucket[bucket].add(edge.source_id);
+  }
+  const totalFeatures = featureEntities.length;
+  const buckets = ["security", "performance", "scalability", "stability", "compliance"];
+  const scores = {};
+  for (const b of buckets) {
+    scores[b] = coveredByBucket[b].size / totalFeatures;
+  }
+  const weights = {
+    security: 1.5,
+    performance: 1,
+    scalability: 1,
+    stability: 1,
+    compliance: 1.5
+  };
+  let weightedSum = 0;
+  let weightTotal = 0;
+  for (const b of buckets) {
+    weightedSum += scores[b] * weights[b];
+    weightTotal += weights[b];
+  }
+  return {
+    security: round(scores.security),
+    performance: round(scores.performance),
+    scalability: round(scores.scalability),
+    stability: round(scores.stability),
+    compliance: round(scores.compliance),
+    overall: round(weightedSum / weightTotal)
+  };
+}
+var BASE_HOURS = {
+  feature: 8,
+  component: 12,
+  data_type: 4
+};
+var NFR_OVERHEAD = {
+  critical: {
+    security: 6,
+    compliance: 5,
+    performance: 4,
+    scalability: 3,
+    stability: 3
+  },
+  warning: { _default: 2 },
+  info: { _default: 0.5 }
+};
+function computeTimeEstimate(entities, edges, constraints, bindings, coverage, conflictCount) {
+  if (entities.length === 0) {
+    return { unassisted_hours: 0, assisted_hours: 0, speedup_factor: 1, confidence: 0 };
+  }
+  let baseHours = 0;
+  const piiDataTypes = /* @__PURE__ */ new Set();
+  for (const entity of entities) {
+    let hours = BASE_HOURS[entity.type] ?? 8;
+    if (entity.type === "data_type") {
+      const isPii = entity.name.toLowerCase().includes("pii") || entity.description?.toLowerCase().includes("personal") || entity.description?.toLowerCase().includes("pii") || entity.name.toLowerCase().includes("financial") || entity.name.toLowerCase().includes("credential");
+      if (isPii) {
+        hours *= 1.3;
+        piiDataTypes.add(entity.id);
+      }
+    }
+    baseHours += hours;
+  }
+  let nfrOverhead = 0;
+  for (const constraint of constraints) {
+    const bucket = toBucket(constraint.category);
+    const severity = constraint.severity;
+    if (severity === "critical" && bucket) {
+      nfrOverhead += NFR_OVERHEAD.critical[bucket] ?? 3;
+    } else if (severity === "warning") {
+      nfrOverhead += NFR_OVERHEAD.warning._default;
+    } else {
+      nfrOverhead += NFR_OVERHEAD.info._default;
+    }
+  }
+  const dependsOnEdges = edges.filter((e) => e.edge_type === "DEPENDS_ON");
+  const dependencyOverhead = Math.max(0, dependsOnEdges.length - 2) * 2;
+  const conflictOverhead = conflictCount * 4;
+  const rawHours = baseHours + nfrOverhead + dependencyOverhead + conflictOverhead;
+  const uncoveredRatio = 1 - coverage.overall;
+  const criticalNfrs = constraints.filter((c) => c.severity === "critical");
+  const hasCriticalGaps = criticalNfrs.length > 0 && coverage.security < 0.5;
+  const reworkMultiplier = hasCriticalGaps ? 1 + uncoveredRatio * 0.6 : 1 + uncoveredRatio * 0.4;
+  const unassistedHours = rawHours * reworkMultiplier;
+  const coveredReduction = coverage.overall * 0.3;
+  const uncoveredReduction = (1 - coverage.overall) * 0.1;
+  const conflictSavings = conflictOverhead * 0.6;
+  const assistedHours = Math.max(
+    rawHours * 0.5,
+    // floor: at least 50% of raw hours
+    rawHours * (1 - coveredReduction - uncoveredReduction) - conflictSavings
+  );
+  const speedup = assistedHours > 0 ? unassistedHours / assistedHours : 1;
+  const boundEntities = new Set(bindings.map((b) => b.entity_id)).size;
+  const bindingRatio = entities.length > 0 ? boundEntities / entities.length : 0;
+  const confidence = Math.min(1, bindingRatio * 0.5 + coverage.overall * 0.5);
+  return {
+    unassisted_hours: round(unassistedHours),
+    assisted_hours: round(assistedHours),
+    speedup_factor: round(speedup, 1),
+    confidence: round(confidence)
+  };
+}
+function computeGraphMetrics(entities, edges, constraints, bindings, conflicts, rgrCompleted, genericPrior) {
+  const nfr_coverage = computeNfrCoverage(entities, edges, constraints);
+  const time_estimate = computeTimeEstimate(entities, edges, constraints, bindings, nfr_coverage, conflicts.length);
+  const criticalNfrCount = constraints.filter((c) => c.severity === "critical").length;
+  const piiCount = entities.filter((e) => {
+    if (e.type !== "data_type")
+      return false;
+    const lower = (e.name + " " + (e.description ?? "")).toLowerCase();
+    return lower.includes("pii") || lower.includes("personal") || lower.includes("financial") || lower.includes("credential");
+  }).length;
+  const dependsOnEdges = edges.filter((e) => e.edge_type === "DEPENDS_ON");
+  let maxDepth = 0;
+  if (dependsOnEdges.length > 0) {
+    const adj = /* @__PURE__ */ new Map();
+    for (const e of dependsOnEdges) {
+      const arr = adj.get(e.source_id) ?? [];
+      arr.push(e.target_id);
+      adj.set(e.source_id, arr);
+    }
+    for (const startId of adj.keys()) {
+      const visited = /* @__PURE__ */ new Set();
+      const queue = [[startId, 0]];
+      visited.add(startId);
+      while (queue.length > 0) {
+        const [id, d] = queue.shift();
+        maxDepth = Math.max(maxDepth, d);
+        for (const next of adj.get(id) ?? []) {
+          if (!visited.has(next)) {
+            visited.add(next);
+            queue.push([next, d + 1]);
+          }
+        }
+      }
+    }
+  }
+  const featureCount = entities.filter((e) => e.type === "feature").length;
+  const frCount = entities.filter((e) => e.type === "component").length;
+  const rgrCompletedPhases = rgrCompleted ?? [];
+  const security_readiness_pct = computeSecurityReadiness(nfr_coverage, constraints, entities, bindings, rgrCompletedPhases, piiCount);
+  const reliability_readiness_pct = computeReliabilityReadiness(nfr_coverage, constraints, entities, bindings, rgrCompletedPhases);
+  const scalability_readiness_pct = computeScalabilityReadiness(nfr_coverage, constraints, entities, bindings, rgrCompletedPhases);
+  const FRAMEWORK_MAP = {
+    soc2: "SOC 2",
+    csa_ccm: "CSA Controls Matrix",
+    pci: "PCI-DSS",
+    hipaa: "HIPAA",
+    fedramp: "FedRAMP",
+    gdpr: "GDPR/CCPA",
+    owasp: "OWASP LLM Top 10",
+    glba: "GLBA",
+    ferpa: "FERPA/COPPA"
+  };
+  const detectedFrameworks = /* @__PURE__ */ new Set();
+  for (const c of constraints) {
+    if (c.id.startsWith("constraint:blueprint:")) {
+      const suffix = c.id.replace("constraint:blueprint:", "");
+      for (const [prefix, label] of Object.entries(FRAMEWORK_MAP)) {
+        if (suffix.startsWith(prefix)) {
+          detectedFrameworks.add(label);
+          break;
+        }
+      }
+    }
+  }
+  const baseMetrics = {
+    nfr_coverage,
+    time_estimate,
+    complexity_factors: {
+      entity_count: entities.length,
+      nfr_count: constraints.length,
+      critical_nfr_count: criticalNfrCount,
+      pii_data_types: piiCount,
+      dependency_depth: maxDepth,
+      conflict_count: conflicts.length
+    },
+    engineering_readiness_pct: computeEngineeringReadiness(nfr_coverage, time_estimate, featureCount, constraints.length, frCount, dependsOnEdges.length, security_readiness_pct, reliability_readiness_pct, scalability_readiness_pct, rgrCompletedPhases, conflicts.length, maxDepth),
+    security_readiness_pct,
+    reliability_readiness_pct,
+    scalability_readiness_pct,
+    rgr_completed_phases: rgrCompletedPhases,
+    compliance_frameworks: detectedFrameworks.size > 0 ? [...detectedFrameworks].sort() : void 0,
+    computed_at: /* @__PURE__ */ new Date()
+  };
+  if (genericPrior) {
+    return applyGenericPrior(baseMetrics, genericPrior, featureCount);
+  }
+  return baseMetrics;
+}
+var SECURITY_CATEGORIES = /* @__PURE__ */ new Set(["security", "compliance", "risk", "accessibility"]);
+function computeSecurityReadiness(coverage, constraints, entities, bindings, rgrCompletedPhases, piiCount) {
+  const secCoverageScore = Math.min(100, coverage.security * 100);
+  const secConstraints = constraints.filter((c) => typeof c.category === "string" && SECURITY_CATEGORIES.has(c.category));
+  const totalEntities = entities.length || 1;
+  const densityRatio = secConstraints.length / totalEntities;
+  const densityScore = Math.min(100, densityRatio * 50);
+  const blueprintConstraints = constraints.filter((c) => c.id.startsWith("constraint:blueprint:") || c.id.startsWith("constraint:audit:"));
+  const frameworkIds = new Set(blueprintConstraints.map((c) => c.id.replace("constraint:blueprint:", "").split("_")[0]).filter((f) => ["soc2", "csa", "pci", "hipaa", "fedramp", "gdpr", "owasp", "glba", "ferpa"].includes(f)));
+  const baseBlueprint = Math.min(60, blueprintConstraints.length * 4);
+  const frameworkBonus = frameworkIds.size * 10;
+  const blueprintScore = Math.min(100, baseBlueprint + frameworkBonus);
+  const complianceScore = Math.min(100, coverage.compliance * 100);
+  const secEntityIds = new Set(entities.filter((e) => e.name.toLowerCase().includes("security") || e.name.toLowerCase().includes("auth")).map((e) => e.id));
+  const boundSecEntities = new Set(bindings.filter((b) => secEntityIds.has(b.entity_id)).map((b) => b.entity_id));
+  const bindingScore = secEntityIds.size > 0 ? Math.min(100, boundSecEntities.size / secEntityIds.size * 100) : blueprintScore > 0 ? 40 : 0;
+  const base = secCoverageScore * 0.35 + densityScore * 0.25 + blueprintScore * 0.2 + complianceScore * 0.1 + bindingScore * 0.1;
+  const piiPenalty = piiCount > 0 ? Math.min(15, piiCount * 5 * (1 - coverage.security)) : 0;
+  let rgrBonus = 0;
+  if (rgrCompletedPhases.includes("security"))
+    rgrBonus += 15;
+  if (rgrCompletedPhases.includes("test_spec"))
+    rgrBonus += 5;
+  if (rgrCompletedPhases.includes("functional"))
+    rgrBonus += 3;
+  if (rgrCompletedPhases.includes("performance"))
+    rgrBonus += 2;
+  return round(Math.min(100, Math.max(0, base - piiPenalty + rgrBonus)));
+}
+var RELIABILITY_KEYWORDS = [
+  "uptime",
+  "availability",
+  "fault",
+  "failover",
+  "recovery",
+  "backup",
+  "retry",
+  "circuit breaker",
+  "redundan",
+  "99.",
+  "sla",
+  "rto",
+  "rpo",
+  "disaster",
+  "high availability",
+  "ha",
+  "replication",
+  "health check"
+];
+function computeReliabilityReadiness(coverage, constraints, entities, bindings, rgrCompletedPhases) {
+  const stabilityCoverageScore = Math.min(100, coverage.stability * 100);
+  const reliabilityConstraints = constraints.filter((c) => {
+    const text = `${c.summary || ""} ${c.action || ""}`.toLowerCase();
+    return RELIABILITY_KEYWORDS.some((kw) => text.includes(kw));
+  });
+  const totalEntities = entities.length || 1;
+  const densityRatio = reliabilityConstraints.length / totalEntities;
+  const densityScore = Math.min(100, densityRatio * 50);
+  const faultTolerancePatterns = ["circuit breaker", "retry", "redundan", "failover", "backup"];
+  const faultToleranceConstraints = constraints.filter((c) => {
+    const text = `${c.summary || ""} ${c.action || ""}`.toLowerCase();
+    return faultTolerancePatterns.some((pattern) => text.includes(pattern));
+  });
+  const faultToleranceScore = Math.min(100, faultToleranceConstraints.length * 10);
+  const observabilityKeywords = ["log", "metric", "monitor", "alert", "trace", "health check"];
+  const observabilityConstraints = constraints.filter((c) => {
+    const text = `${c.summary || ""} ${c.action || ""}`.toLowerCase();
+    return observabilityKeywords.some((kw) => text.includes(kw));
+  });
+  const observabilityScore = Math.min(100, observabilityConstraints.length * 8);
+  const persistenceKeywords = ["backup", "replication", "disaster recovery", "snapshot", "restore"];
+  const persistenceConstraints = constraints.filter((c) => {
+    const text = `${c.summary || ""} ${c.action || ""}`.toLowerCase();
+    return persistenceKeywords.some((kw) => text.includes(kw));
+  });
+  const persistenceScore = Math.min(100, persistenceConstraints.length * 12);
+  const base = stabilityCoverageScore * 0.35 + densityScore * 0.25 + faultToleranceScore * 0.2 + observabilityScore * 0.1 + persistenceScore * 0.1;
+  let rgrBonus = 0;
+  if (rgrCompletedPhases.includes("stability"))
+    rgrBonus += 10;
+  if (rgrCompletedPhases.includes("observability"))
+    rgrBonus += 5;
+  if (rgrCompletedPhases.includes("test_spec"))
+    rgrBonus += 3;
+  return round(Math.min(100, Math.max(0, base + rgrBonus)));
+}
+var SCALABILITY_KEYWORDS = [
+  "concurrent",
+  "scale",
+  "scaling",
+  "growth",
+  "horizontal",
+  "vertical",
+  "shard",
+  "partition",
+  "capacity",
+  "rate limit",
+  "load balanc",
+  "autoscal",
+  "elastic",
+  "throughput",
+  "queue",
+  "async",
+  "cache",
+  "cdn",
+  "distributed"
+];
+function computeScalabilityReadiness(coverage, constraints, entities, bindings, rgrCompletedPhases) {
+  const scalabilityCoverageScore = Math.min(100, coverage.scalability * 100);
+  const scalabilityConstraints = constraints.filter((c) => {
+    const text = `${c.summary || ""} ${c.action || ""}`.toLowerCase();
+    return SCALABILITY_KEYWORDS.some((kw) => text.includes(kw));
+  });
+  const totalEntities = entities.length || 1;
+  const densityRatio = scalabilityConstraints.length / totalEntities;
+  const densityScore = Math.min(100, densityRatio * 50);
+  const scalePatterns = ["horizontal", "vertical", "shard", "partition", "load balanc", "autoscal"];
+  const scalePatternConstraints = constraints.filter((c) => {
+    const text = `${c.summary || ""} ${c.action || ""}`.toLowerCase();
+    return scalePatterns.some((pattern) => text.includes(pattern));
+  });
+  const scalePatternScore = Math.min(100, scalePatternConstraints.length * 10);
+  const performanceScore = Math.min(100, coverage.performance * 100);
+  const infraKeywords = ["cache", "cdn", "queue", "async", "distributed"];
+  const infraConstraints = constraints.filter((c) => {
+    const text = `${c.summary || ""} ${c.action || ""}`.toLowerCase();
+    return infraKeywords.some((kw) => text.includes(kw));
+  });
+  const infraScore = Math.min(100, infraConstraints.length * 12);
+  const base = scalabilityCoverageScore * 0.35 + densityScore * 0.25 + scalePatternScore * 0.2 + performanceScore * 0.1 + infraScore * 0.1;
+  let rgrBonus = 0;
+  if (rgrCompletedPhases.includes("performance"))
+    rgrBonus += 10;
+  if (rgrCompletedPhases.includes("infrastructure"))
+    rgrBonus += 5;
+  if (rgrCompletedPhases.includes("scalability"))
+    rgrBonus += 8;
+  return round(Math.min(100, Math.max(0, base + rgrBonus)));
+}
+function computeEngineeringReadiness(coverage, time, featureCount, constraintCount, frCount, depEdgeCount, securityReadinessPct, reliabilityReadinessPct, scalabilityReadinessPct, rgrCompletedPhases, conflictCount, depDepth) {
+  const speedupScore = Math.min(100, 30 + (time.speedup_factor - 1) * 35);
+  const nfrScore = Math.min(100, coverage.overall * 100);
+  const depthScore = featureCount > 0 ? Math.min(100, constraintCount / featureCount * 25) : 0;
+  let structScore = 0;
+  if (featureCount > 0)
+    structScore += 40;
+  if (frCount > 0)
+    structScore += 30;
+  if (depEdgeCount > 0)
+    structScore += 15;
+  if (constraintCount > 0)
+    structScore += 15;
+  const base = speedupScore * 0.25 + nfrScore * 0.15 + securityReadinessPct * 0.15 + reliabilityReadinessPct * 0.1 + scalabilityReadinessPct * 0.1 + depthScore * 0.1 + structScore * 0.15;
+  const conflictPenalty = Math.min(15, conflictCount * 3);
+  const depthRiskPenalty = depDepth > 2 ? Math.min(10, (depDepth - 2) * 3 * (1 - coverage.overall)) : 0;
+  let rgrBonus = 0;
+  if (rgrCompletedPhases.includes("test_spec"))
+    rgrBonus += 5;
+  if (rgrCompletedPhases.includes("functional"))
+    rgrBonus += 5;
+  if (rgrCompletedPhases.includes("performance"))
+    rgrBonus += 3;
+  if (rgrCompletedPhases.includes("economics"))
+    rgrBonus += 2;
+  return round(Math.min(100, Math.max(0, base - conflictPenalty - depthRiskPenalty + rgrBonus)));
+}
+function computeMetricsFromGraph(entities, edges, constraints, bindings, rgrCompleted, genericPrior) {
+  const traverser = new GraphTraverser(entities, edges, constraints, bindings);
+  const allConflicts = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const entity of entities) {
+    const sub = traverser.getSubgraph(entity.id, 1);
+    if (sub?.conflicts) {
+      for (const c of sub.conflicts) {
+        const key = `${c.constraint_a.id}:${c.constraint_b.id}`;
+        if (!seen.has(key)) {
+          seen.add(key);
+          allConflicts.push(c);
+        }
+      }
+    }
+  }
+  return computeGraphMetrics(entities, edges, constraints, bindings, allConflicts, rgrCompleted, genericPrior);
+}
+var SEVERITY_WEIGHT = { critical: 3, warning: 2, info: 1 };
+function computeBindingCoverage(entities, edges, constraints, bindings) {
+  if (constraints.length === 0) {
+    return { security: 0, performance: 0, scalability: 0, stability: 0, compliance: 0, overall: 0 };
+  }
+  const boundEntityIds = new Set(bindings.map((b) => b.entity_id));
+  const constraintToEntities = /* @__PURE__ */ new Map();
+  for (const edge of edges) {
+    if (edge.edge_type !== "GOVERNED_BY" && edge.edge_type !== "BOUNDED_BY")
+      continue;
+    const existing = constraintToEntities.get(edge.target_id) ?? /* @__PURE__ */ new Set();
+    existing.add(edge.source_id);
+    constraintToEntities.set(edge.target_id, existing);
+  }
+  const buckets = ["security", "performance", "scalability", "stability", "compliance"];
+  const totalWeight = { security: 0, performance: 0, scalability: 0, stability: 0, compliance: 0 };
+  const boundWeight = { security: 0, performance: 0, scalability: 0, stability: 0, compliance: 0 };
+  for (const c of constraints) {
+    const bucket = toBucket(c.category);
+    if (!bucket)
+      continue;
+    const w = SEVERITY_WEIGHT[c.severity] ?? 1;
+    totalWeight[bucket] += w;
+    const linkedEntities = constraintToEntities.get(c.id);
+    if (linkedEntities) {
+      for (const eid of linkedEntities) {
+        if (boundEntityIds.has(eid)) {
+          boundWeight[bucket] += w;
+          break;
+        }
+      }
+    }
+  }
+  const scores = {};
+  for (const b of buckets) {
+    scores[b] = totalWeight[b] > 0 ? boundWeight[b] / totalWeight[b] : 0;
+  }
+  const weights = { security: 1.5, performance: 1, scalability: 1, stability: 1, compliance: 1.5 };
+  let weightedSum = 0;
+  let wTotal = 0;
+  for (const b of buckets) {
+    weightedSum += scores[b] * weights[b];
+    wTotal += weights[b];
+  }
+  return {
+    security: round(scores.security),
+    performance: round(scores.performance),
+    scalability: round(scores.scalability),
+    stability: round(scores.stability),
+    compliance: round(scores.compliance),
+    overall: round(weightedSum / wTotal)
+  };
+}
+function computeGenericGraphMetrics(entities, edges, constraints, bindings) {
+  const nfr_coverage = computeBindingCoverage(entities, edges, constraints, bindings);
+  const conflicts = [];
+  if (entities.length > 0) {
+    const traverser = new GraphTraverser(entities, edges, constraints, bindings);
+    const seen = /* @__PURE__ */ new Set();
+    for (const entity of entities) {
+      const sub = traverser.getSubgraph(entity.id, 1);
+      if (sub?.conflicts) {
+        for (const c of sub.conflicts) {
+          const key = `${c.constraint_a.id}:${c.constraint_b.id}`;
+          if (!seen.has(key)) {
+            seen.add(key);
+            conflicts.push(c);
+          }
+        }
+      }
+    }
+  }
+  const time_estimate = computeTimeEstimate(entities, edges, constraints, bindings, nfr_coverage, conflicts.length);
+  const criticalNfrCount = constraints.filter((c) => c.severity === "critical").length;
+  const piiCount = entities.filter((e) => {
+    if (e.type !== "data_type")
+      return false;
+    const lower = (e.name + " " + (e.description ?? "")).toLowerCase();
+    return lower.includes("pii") || lower.includes("personal") || lower.includes("financial") || lower.includes("credential");
+  }).length;
+  const security_readiness_pct = computeSecurityReadiness(nfr_coverage, constraints, entities, bindings, [], piiCount);
+  const reliability_readiness_pct = computeReliabilityReadiness(nfr_coverage, constraints, entities, bindings, []);
+  const scalability_readiness_pct = computeScalabilityReadiness(nfr_coverage, constraints, entities, bindings, []);
+  const FRAMEWORK_MAP = {
+    soc2: "SOC 2",
+    csa_ccm: "CSA Controls Matrix",
+    pci: "PCI-DSS",
+    hipaa: "HIPAA",
+    fedramp: "FedRAMP",
+    gdpr: "GDPR/CCPA",
+    owasp: "OWASP LLM Top 10",
+    glba: "GLBA",
+    ferpa: "FERPA/COPPA"
+  };
+  const detectedFrameworks = /* @__PURE__ */ new Set();
+  for (const c of constraints) {
+    if (c.id.startsWith("constraint:blueprint:")) {
+      const suffix = c.id.replace("constraint:blueprint:", "");
+      for (const [prefix, label] of Object.entries(FRAMEWORK_MAP)) {
+        if (suffix.startsWith(prefix)) {
+          detectedFrameworks.add(label);
+          break;
+        }
+      }
+    }
+  }
+  const frCount = entities.filter((e) => e.type === "component").length;
+  const engineering_readiness_pct = computeEngineeringReadiness(nfr_coverage, time_estimate, 0, constraints.length, frCount, 0, security_readiness_pct, reliability_readiness_pct, scalability_readiness_pct, [], conflicts.length, 0);
+  return {
+    nfr_coverage,
+    time_estimate,
+    complexity_factors: {
+      entity_count: entities.length,
+      nfr_count: constraints.length,
+      critical_nfr_count: criticalNfrCount,
+      pii_data_types: piiCount,
+      dependency_depth: 0,
+      conflict_count: conflicts.length
+    },
+    engineering_readiness_pct,
+    security_readiness_pct,
+    reliability_readiness_pct,
+    scalability_readiness_pct,
+    rgr_completed_phases: [],
+    compliance_frameworks: detectedFrameworks.size > 0 ? [...detectedFrameworks].sort() : void 0,
+    computed_at: /* @__PURE__ */ new Date()
+  };
+}
+var PRIOR_MATURITY_THRESHOLD = 5;
+function blendWithPrior(productScore, genericScore, featureCount) {
+  if (genericScore === void 0 || genericScore === 0)
+    return productScore;
+  const alpha = Math.min(1, featureCount / PRIOR_MATURITY_THRESHOLD);
+  return Math.round(alpha * productScore + (1 - alpha) * genericScore);
+}
+function applyGenericPrior(metrics, prior, featureCount) {
+  return {
+    ...metrics,
+    engineering_readiness_pct: blendWithPrior(metrics.engineering_readiness_pct ?? 0, prior.engineering_readiness_pct, featureCount),
+    security_readiness_pct: blendWithPrior(metrics.security_readiness_pct ?? 0, prior.security_readiness_pct, featureCount),
+    reliability_readiness_pct: blendWithPrior(metrics.reliability_readiness_pct ?? 0, prior.reliability_readiness_pct, featureCount),
+    scalability_readiness_pct: blendWithPrior(metrics.scalability_readiness_pct ?? 0, prior.scalability_readiness_pct, featureCount)
+  };
+}
+function round(n, decimals = 2) {
+  const factor = 10 ** decimals;
+  return Math.round(n * factor) / factor;
+}
+
+export {
+  detectConstraintConflicts,
+  GraphTraverser,
+  computeGraphMetrics,
+  computeMetricsFromGraph,
+  computeGenericGraphMetrics,
+  applyGenericPrior
+};