@harness-engineering/graph 0.2.0 → 0.2.2

package/dist/index.mjs

@@ -31,7 +31,11 @@ var NODE_TYPES = [
   "layer",
   "pattern",
   "constraint",
-  "violation"
+  "violation",
+  // Design
+  "design_token",
+  "aesthetic_intent",
+  "design_constraint"
 ];
 var EDGE_TYPES = [
   // Code relationships
@@ -55,7 +59,12 @@ var EDGE_TYPES = [
   "failed_in",
   // Execution relationships (future)
   "executed_by",
-  "measured_by"
+  "measured_by",
+  // Design relationships
+  "uses_token",
+  "declares_intent",
+  "violates_design",
+  "platform_binding"
 ];
 var OBSERVABILITY_TYPES = /* @__PURE__ */ new Set(["span", "metric", "log"]);
 var CURRENT_SCHEMA_VERSION = 1;
@@ -124,6 +133,14 @@ async function loadGraph(dirPath) {
 }
 
 // src/store/GraphStore.ts
+var POISONED_KEYS = /* @__PURE__ */ new Set(["__proto__", "constructor", "prototype"]);
+function safeMerge(target, source) {
+  for (const key of Object.keys(source)) {
+    if (!POISONED_KEYS.has(key)) {
+      target[key] = source[key];
+    }
+  }
+}
 var GraphStore = class {
   db;
   nodes;
@@ -142,7 +159,7 @@ var GraphStore = class {
   addNode(node) {
     const existing = this.nodes.by("id", node.id);
     if (existing) {
-      Object.assign(existing, node);
+      safeMerge(existing, node);
       this.nodes.update(existing);
     } else {
       this.nodes.insert({ ...node });
@@ -186,7 +203,7 @@ var GraphStore = class {
     });
     if (existing) {
       if (edge.metadata) {
-        Object.assign(existing, edge);
+        safeMerge(existing, edge);
         this.edges.update(existing);
       }
       return;
@@ -462,7 +479,7 @@ var CodeIngestor = class {
     let nodesAdded = 0;
     let edgesAdded = 0;
     const files = await this.findSourceFiles(rootDir);
-    const callableNodes = [];
+    const nameToFiles = /* @__PURE__ */ new Map();
     const fileContents = /* @__PURE__ */ new Map();
     for (const filePath of files) {
       try {
@@ -488,7 +505,12 @@ var CodeIngestor = class {
           nodesAdded++;
           edgesAdded++;
           if (node.type === "function" || node.type === "method") {
-            callableNodes.push({ id: node.id, name: node.name, filePath: relativePath });
+            let files2 = nameToFiles.get(node.name);
+            if (!files2) {
+              files2 = /* @__PURE__ */ new Set();
+              nameToFiles.set(node.name, files2);
+            }
+            files2.add(relativePath);
           }
         }
         const imports = await this.extractImports(content, fileId, relativePath, rootDir);
@@ -500,7 +522,7 @@ var CodeIngestor = class {
         errors.push(`${filePath}: ${err instanceof Error ? err.message : String(err)}`);
       }
     }
-    const callsEdges = this.extractCallsEdges(callableNodes, fileContents);
+    const callsEdges = this.extractCallsEdges(nameToFiles, fileContents);
     for (const edge of callsEdges) {
       this.store.addEdge(edge);
       edgesAdded++;
@@ -548,7 +570,13 @@ var CodeIngestor = class {
             name,
             path: relativePath,
             location: { fileId, startLine: i + 1, endLine },
-            metadata: { exported: line.includes("export") }
+            metadata: {
+              exported: line.includes("export"),
+              cyclomaticComplexity: this.computeCyclomaticComplexity(lines.slice(i, endLine)),
+              nestingDepth: this.computeMaxNesting(lines.slice(i, endLine)),
+              lineCount: endLine - i,
+              parameterCount: this.countParameters(line)
+            }
           },
           edge: { from: fileId, to: id, type: "contains" }
         });
@@ -634,7 +662,14 @@ var CodeIngestor = class {
               name: methodName,
               path: relativePath,
               location: { fileId, startLine: i + 1, endLine },
-              metadata: { className: currentClassName, exported: false }
+              metadata: {
+                className: currentClassName,
+                exported: false,
+                cyclomaticComplexity: this.computeCyclomaticComplexity(lines.slice(i, endLine)),
+                nestingDepth: this.computeMaxNesting(lines.slice(i, endLine)),
+                lineCount: endLine - i,
+                parameterCount: this.countParameters(line)
+              }
             },
             edge: { from: currentClassId, to: id, type: "contains" }
           });
@@ -684,43 +719,37 @@ var CodeIngestor = class {
     return startIndex + 1;
   }
   /**
-   * Second pass: for each function/method, check if its file content calls any other
-   * known function/method. Creates approximate "calls" edges via regex matching.
+   * Second pass: scan each file for identifiers matching known callable names,
+   * then create file-to-file "calls" edges. Uses regex heuristic (not AST).
    */
-  extractCallsEdges(callableNodes, fileContents) {
+  extractCallsEdges(nameToFiles, fileContents) {
     const edges = [];
-    const nameToNodes = /* @__PURE__ */ new Map();
-    for (const callable of callableNodes) {
-      let arr = nameToNodes.get(callable.name);
-      if (!arr) {
-        arr = [];
-        nameToNodes.set(callable.name, arr);
-      }
-      arr.push({ id: callable.id, filePath: callable.filePath });
-    }
-    for (const caller of callableNodes) {
-      const content = fileContents.get(caller.filePath);
-      if (!content) continue;
-      for (const [name, targets] of nameToNodes) {
-        if (name === caller.name) continue;
-        const callPattern = new RegExp(`\\b${this.escapeRegex(name)}\\s*\\(`, "g");
-        if (callPattern.test(content)) {
-          for (const target of targets) {
-            edges.push({
-              from: caller.id,
-              to: target.id,
-              type: "calls",
-              metadata: { confidence: "regex" }
-            });
-          }
+    const seen = /* @__PURE__ */ new Set();
+    for (const [filePath, content] of fileContents) {
+      const callerFileId = `file:${filePath}`;
+      const callPattern = /\b([a-zA-Z_$][\w$]*)\s*\(/g;
+      let match;
+      while ((match = callPattern.exec(content)) !== null) {
+        const name = match[1];
+        const targetFiles = nameToFiles.get(name);
+        if (!targetFiles) continue;
+        for (const targetFile of targetFiles) {
+          if (targetFile === filePath) continue;
+          const targetFileId = `file:${targetFile}`;
+          const key = `${callerFileId}|${targetFileId}`;
+          if (seen.has(key)) continue;
+          seen.add(key);
+          edges.push({
+            from: callerFileId,
+            to: targetFileId,
+            type: "calls",
+            metadata: { confidence: "regex" }
+          });
         }
       }
     }
     return edges;
   }
-  escapeRegex(str) {
-    return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-  }
   async extractImports(content, fileId, relativePath, rootDir) {
     const edges = [];
     const importRegex = /import\s+(?:type\s+)?(?:\{[^}]*\}|[\w*]+)\s+from\s+['"]([^'"]+)['"]/g;
@@ -766,6 +795,46 @@ var CodeIngestor = class {
     }
     return null;
   }
+  computeCyclomaticComplexity(lines) {
+    let complexity = 1;
+    const decisionPattern = /\b(if|else\s+if|while|for|case)\b|\?\s*[^:?]|&&|\|\||catch\b/g;
+    for (const line of lines) {
+      const trimmed = line.trim();
+      if (trimmed.startsWith("//") || trimmed.startsWith("*")) continue;
+      const matches = trimmed.match(decisionPattern);
+      if (matches) complexity += matches.length;
+    }
+    return complexity;
+  }
+  computeMaxNesting(lines) {
+    let maxDepth = 0;
+    let currentDepth = 0;
+    for (const line of lines) {
+      const trimmed = line.trim();
+      if (trimmed.startsWith("//") || trimmed.startsWith("*")) continue;
+      for (const ch of trimmed) {
+        if (ch === "{") {
+          currentDepth++;
+          if (currentDepth > maxDepth) maxDepth = currentDepth;
+        } else if (ch === "}") {
+          currentDepth--;
+        }
+      }
+    }
+    return Math.max(0, maxDepth - 1);
+  }
+  countParameters(declarationLine) {
+    const parenMatch = declarationLine.match(/\(([^)]*)\)/);
+    if (!parenMatch || !parenMatch[1].trim()) return 0;
+    let depth = 0;
+    let count = 1;
+    for (const ch of parenMatch[1]) {
+      if (ch === "<" || ch === "(") depth++;
+      else if (ch === ">" || ch === ")") depth--;
+      else if (ch === "," && depth === 0) count++;
+    }
+    return count;
+  }
   detectLanguage(filePath) {
     if (/\.tsx?$/.test(filePath)) return "typescript";
     if (/\.jsx?$/.test(filePath)) return "javascript";
@@ -1032,8 +1101,9 @@ var TopologicalLinker = class {
 // src/ingest/KnowledgeIngestor.ts
 import * as fs2 from "fs/promises";
 import * as path3 from "path";
+
+// src/ingest/ingestUtils.ts
 import * as crypto from "crypto";
-var CODE_NODE_TYPES = ["file", "function", "class", "method", "interface", "variable"];
 function hash(text) {
   return crypto.createHash("md5").update(text).digest("hex").slice(0, 8);
 }
@@ -1050,6 +1120,9 @@ function mergeResults(...results) {
 function emptyResult(durationMs = 0) {
   return { nodesAdded: 0, nodesUpdated: 0, edgesAdded: 0, edgesUpdated: 0, errors: [], durationMs };
 }
+
+// src/ingest/KnowledgeIngestor.ts
+var CODE_NODE_TYPES = ["file", "function", "class", "method", "interface", "variable"];
 var KnowledgeIngestor = class {
   constructor(store) {
     this.store = store;
@@ -1241,6 +1314,22 @@ var KnowledgeIngestor = class {
 
 // src/ingest/connectors/ConnectorUtils.ts
 var CODE_NODE_TYPES2 = ["file", "function", "class", "method", "interface", "variable"];
+function sanitizeExternalText(text, maxLength = 2e3) {
+  let sanitized = text.replace(
+    /<\/?(?:system|instruction|prompt|role|context|tool_call|function_call|assistant|human|user)[^>]*>/gi,
+    ""
+  ).replace(/^#{1,3}\s*(?:system|instruction|prompt)\s*[:：]\s*/gim, "").replace(
+    /(?:ignore|disregard|forget)\s+(?:all\s+)?(?:previous|prior|above)\s+(?:instructions?|prompts?|context)/gi,
+    "[filtered]"
+  ).replace(
+    /you\s+are\s+now\s+(?:a\s+)?(?:helpful\s+)?(?:an?\s+)?(?:assistant|system|ai|bot|agent|tool)\b/gi,
+    "[filtered]"
+  );
+  if (sanitized.length > maxLength) {
+    sanitized = sanitized.slice(0, maxLength) + "\u2026";
+  }
+  return sanitized;
+}
 function linkToCode(store, content, sourceNodeId, edgeType, options) {
   let edgesCreated = 0;
   for (const type of CODE_NODE_TYPES2) {
@@ -1408,7 +1497,7 @@ var JiraConnector = class {
           store.addNode({
             id: nodeId,
             type: "issue",
-            name: issue.fields.summary,
+            name: sanitizeExternalText(issue.fields.summary, 500),
             metadata: {
               key: issue.key,
               status: issue.fields.status?.name,
@@ -1418,7 +1507,9 @@ var JiraConnector = class {
             }
           });
           nodesAdded++;
-          const searchText = [issue.fields.summary, issue.fields.description ?? ""].join(" ");
+          const searchText = sanitizeExternalText(
+            [issue.fields.summary, issue.fields.description ?? ""].join(" ")
+          );
           edgesAdded += linkToCode(store, searchText, nodeId, "applies_to");
         }
         startAt += maxResults;
@@ -1494,7 +1585,8 @@ var SlackConnector = class {
         }
         for (const message of data.messages) {
           const nodeId = `conversation:slack:${channel}:${message.ts}`;
-          const snippet = message.text.length > 100 ? message.text.slice(0, 100) : message.text;
+          const sanitizedText = sanitizeExternalText(message.text);
+          const snippet = sanitizedText.length > 100 ? sanitizedText.slice(0, 100) : sanitizedText;
           store.addNode({
             id: nodeId,
             type: "conversation",
@@ -1506,7 +1598,9 @@ var SlackConnector = class {
             }
           });
           nodesAdded++;
-          edgesAdded += linkToCode(store, message.text, nodeId, "references", { checkPaths: true });
+          edgesAdded += linkToCode(store, sanitizedText, nodeId, "references", {
+            checkPaths: true
+          });
         }
       } catch (err) {
         errors.push(
@@ -1569,7 +1663,7 @@ var ConfluenceConnector = class {
           store.addNode({
             id: nodeId,
             type: "document",
-            name: page.title,
+            name: sanitizeExternalText(page.title, 500),
             metadata: {
               source: "confluence",
               spaceKey,
@@ -1579,7 +1673,7 @@ var ConfluenceConnector = class {
             }
           });
           nodesAdded++;
-          const text = `${page.title} ${page.body?.storage?.value ?? ""}`;
+          const text = sanitizeExternalText(`${page.title} ${page.body?.storage?.value ?? ""}`);
           edgesAdded += linkToCode(store, text, nodeId, "documents");
         }
         nextUrl = data._links?.next ? `${baseUrl}${data._links.next}` : null;
@@ -1644,10 +1738,11 @@ var CIConnector = class {
       const data = await response.json();
       for (const run of data.workflow_runs) {
         const buildId = `build:${run.id}`;
+        const safeName = sanitizeExternalText(run.name, 200);
         store.addNode({
           id: buildId,
           type: "build",
-          name: `${run.name} #${run.id}`,
+          name: `${safeName} #${run.id}`,
           metadata: {
             source: "github-actions",
             status: run.status,
@@ -1669,7 +1764,7 @@ var CIConnector = class {
           store.addNode({
             id: testResultId,
             type: "test_result",
-            name: `Failed: ${run.name} #${run.id}`,
+            name: `Failed: ${safeName} #${run.id}`,
             metadata: {
               source: "github-actions",
               buildId: String(run.id),
@@ -1972,6 +2067,144 @@ var GraphEntropyAdapter = class {
   }
 };
 
+// src/entropy/GraphComplexityAdapter.ts
+var GraphComplexityAdapter = class {
+  constructor(store) {
+    this.store = store;
+  }
+  /**
+   * Compute complexity hotspots by combining cyclomatic complexity with change frequency.
+   *
+   * 1. Find all function and method nodes
+   * 2. For each, find the containing file and count commit nodes referencing that file
+   * 3. Compute hotspotScore = changeFrequency * cyclomaticComplexity
+   * 4. Sort descending by score
+   * 5. Compute 95th percentile
+   */
+  computeComplexityHotspots() {
+    const functionNodes = [
+      ...this.store.findNodes({ type: "function" }),
+      ...this.store.findNodes({ type: "method" })
+    ];
+    if (functionNodes.length === 0) {
+      return { hotspots: [], percentile95Score: 0 };
+    }
+    const fileChangeFrequency = /* @__PURE__ */ new Map();
+    const hotspots = [];
+    for (const fnNode of functionNodes) {
+      const complexity = fnNode.metadata?.cyclomaticComplexity ?? 1;
+      const containsEdges = this.store.getEdges({ to: fnNode.id, type: "contains" });
+      let fileId;
+      for (const edge of containsEdges) {
+        const sourceNode = this.store.getNode(edge.from);
+        if (sourceNode?.type === "file") {
+          fileId = sourceNode.id;
+          break;
+        }
+        if (sourceNode?.type === "class") {
+          const classContainsEdges = this.store.getEdges({ to: sourceNode.id, type: "contains" });
+          for (const classEdge of classContainsEdges) {
+            const parentNode = this.store.getNode(classEdge.from);
+            if (parentNode?.type === "file") {
+              fileId = parentNode.id;
+              break;
+            }
+          }
+          if (fileId) break;
+        }
+      }
+      if (!fileId) continue;
+      let changeFrequency = fileChangeFrequency.get(fileId);
+      if (changeFrequency === void 0) {
+        const referencesEdges = this.store.getEdges({ to: fileId, type: "references" });
+        changeFrequency = referencesEdges.length;
+        fileChangeFrequency.set(fileId, changeFrequency);
+      }
+      const hotspotScore = changeFrequency * complexity;
+      const filePath = fnNode.path ?? fileId.replace(/^file:/, "");
+      hotspots.push({
+        file: filePath,
+        function: fnNode.name,
+        changeFrequency,
+        complexity,
+        hotspotScore
+      });
+    }
+    hotspots.sort((a, b) => b.hotspotScore - a.hotspotScore);
+    const percentile95Score = this.computePercentile(
+      hotspots.map((h) => h.hotspotScore),
+      95
+    );
+    return { hotspots, percentile95Score };
+  }
+  computePercentile(descendingScores, percentile) {
+    if (descendingScores.length === 0) return 0;
+    const ascending = [...descendingScores].sort((a, b) => a - b);
+    const index = Math.ceil(percentile / 100 * ascending.length) - 1;
+    return ascending[Math.min(index, ascending.length - 1)];
+  }
+};
+
+// src/entropy/GraphCouplingAdapter.ts
+var GraphCouplingAdapter = class {
+  constructor(store) {
+    this.store = store;
+  }
+  /**
+   * Compute coupling data for all file nodes in the graph.
+   *
+   * For each file:
+   * - fanOut: number of outbound 'imports' edges
+   * - fanIn: number of inbound 'imports' edges from other files
+   * - couplingRatio: fanOut / (fanIn + fanOut), rounded to 2 decimals (0 if both are 0)
+   * - transitiveDepth: longest chain of outbound 'imports' edges via BFS
+   */
+  computeCouplingData() {
+    const fileNodes = this.store.findNodes({ type: "file" });
+    if (fileNodes.length === 0) {
+      return { files: [] };
+    }
+    const files = [];
+    for (const node of fileNodes) {
+      const fileId = node.id;
+      const filePath = node.path ?? node.name;
+      const outEdges = this.store.getEdges({ from: fileId, type: "imports" });
+      const fanOut = outEdges.length;
+      const inEdges = this.store.getEdges({ to: fileId, type: "imports" });
+      const fanIn = inEdges.length;
+      const total = fanIn + fanOut;
+      const couplingRatio = total === 0 ? 0 : Math.round(fanOut / total * 100) / 100;
+      const transitiveDepth = this.computeTransitiveDepth(fileId);
+      files.push({ file: filePath, fanIn, fanOut, couplingRatio, transitiveDepth });
+    }
+    return { files };
+  }
+  /**
+   * BFS from a node following outbound 'imports' edges to find the maximum depth.
+   */
+  computeTransitiveDepth(startId) {
+    const visited = /* @__PURE__ */ new Set();
+    const queue = [[startId, 0]];
+    visited.add(startId);
+    let maxDepth = 0;
+    let head = 0;
+    while (head < queue.length) {
+      const [nodeId, depth] = queue[head++];
+      if (depth > maxDepth) {
+        maxDepth = depth;
+      }
+      const outEdges = this.store.getEdges({ from: nodeId, type: "imports" });
+      for (const edge of outEdges) {
+        if (!visited.has(edge.to)) {
+          visited.add(edge.to);
+          queue.push([edge.to, depth + 1]);
+        }
+      }
+    }
+    return maxDepth;
+  }
+};
+
 // src/context/Assembler.ts
 var PHASE_NODE_TYPES = {
   implement: ["file", "function", "class", "method", "interface", "variable"],
@@ -2279,6 +2512,250 @@ var GraphConstraintAdapter = class {
   }
 };
 
+// src/ingest/DesignIngestor.ts
+import * as fs4 from "fs/promises";
+import * as path5 from "path";
+function isDTCGToken(obj) {
+  return typeof obj === "object" && obj !== null && "$value" in obj && "$type" in obj;
+}
+async function readFileOrNull(filePath) {
+  try {
+    return await fs4.readFile(filePath, "utf-8");
+  } catch {
+    return null;
+  }
+}
+function parseJsonOrError(content, filePath) {
+  try {
+    return { data: JSON.parse(content) };
+  } catch (err) {
+    return {
+      error: `Failed to parse ${filePath}: ${err instanceof Error ? err.message : String(err)}`
+    };
+  }
+}
+function walkDTCGTokens(store, obj, groupPath, topGroup, tokensPath) {
+  let count = 0;
+  for (const [key, value] of Object.entries(obj)) {
+    if (key.startsWith("$")) continue;
+    if (isDTCGToken(value)) {
+      const tokenPath = [...groupPath, key].join(".");
+      store.addNode({
+        id: `design_token:${tokenPath}`,
+        type: "design_token",
+        name: tokenPath,
+        path: tokensPath,
+        metadata: {
+          tokenType: value.$type,
+          value: value.$value,
+          group: topGroup || groupPath[0] || key,
+          ...value.$description ? { description: value.$description } : {}
+        }
+      });
+      count++;
+    } else if (typeof value === "object" && value !== null) {
+      count += walkDTCGTokens(
+        store,
+        value,
+        [...groupPath, key],
+        topGroup || key,
+        tokensPath
+      );
+    }
+  }
+  return count;
+}
+function parseAestheticDirection(content) {
+  const extract = (pattern) => {
+    const m = content.match(pattern);
+    return m ? m[1].trim() : void 0;
+  };
+  const result = {};
+  const style = extract(/\*\*Style:\*\*\s*(.+)/);
+  if (style !== void 0) result.style = style;
+  const tone = extract(/\*\*Tone:\*\*\s*(.+)/);
+  if (tone !== void 0) result.tone = tone;
+  const differentiator = extract(/\*\*Differentiator:\*\*\s*(.+)/);
+  if (differentiator !== void 0) result.differentiator = differentiator;
+  const strictness = extract(/^level:\s*(strict|standard|permissive)\s*$/m);
+  if (strictness !== void 0) result.strictness = strictness;
+  return result;
+}
+function parseAntiPatterns(content) {
+  const lines = content.split("\n");
+  const patterns = [];
+  let inSection = false;
+  for (const line of lines) {
+    if (/^##\s+Anti-Patterns/i.test(line)) {
+      inSection = true;
+      continue;
+    }
+    if (inSection && /^##\s+/.test(line)) {
+      break;
+    }
+    if (inSection) {
+      const bulletMatch = line.match(/^-\s+(.+)/);
+      if (bulletMatch) {
+        patterns.push(bulletMatch[1].trim());
+      }
+    }
+  }
+  return patterns;
+}
+var DesignIngestor = class {
+  constructor(store) {
+    this.store = store;
+  }
+  async ingestTokens(tokensPath) {
+    const start = Date.now();
+    const content = await readFileOrNull(tokensPath);
+    if (content === null) return emptyResult(Date.now() - start);
+    const parsed = parseJsonOrError(content, tokensPath);
+    if ("error" in parsed) {
+      return { ...emptyResult(Date.now() - start), errors: [parsed.error] };
+    }
+    const nodesAdded = walkDTCGTokens(this.store, parsed.data, [], "", tokensPath);
+    return {
+      nodesAdded,
+      nodesUpdated: 0,
+      edgesAdded: 0,
+      edgesUpdated: 0,
+      errors: [],
+      durationMs: Date.now() - start
+    };
+  }
+  async ingestDesignIntent(designPath) {
+    const start = Date.now();
+    const content = await readFileOrNull(designPath);
+    if (content === null) return emptyResult(Date.now() - start);
+    let nodesAdded = 0;
+    const direction = parseAestheticDirection(content);
+    const metadata = {};
+    if (direction.style) metadata.style = direction.style;
+    if (direction.tone) metadata.tone = direction.tone;
+    if (direction.differentiator) metadata.differentiator = direction.differentiator;
+    if (direction.strictness) metadata.strictness = direction.strictness;
+    this.store.addNode({
+      id: "aesthetic_intent:project",
+      type: "aesthetic_intent",
+      name: "project",
+      path: designPath,
+      metadata
+    });
+    nodesAdded++;
+    for (const text of parseAntiPatterns(content)) {
+      this.store.addNode({
+        id: `design_constraint:${hash(text)}`,
+        type: "design_constraint",
+        name: text,
+        path: designPath,
+        metadata: { rule: text, severity: "warn", scope: "project" }
+      });
+      nodesAdded++;
+    }
+    return {
+      nodesAdded,
+      nodesUpdated: 0,
+      edgesAdded: 0,
+      edgesUpdated: 0,
+      errors: [],
+      durationMs: Date.now() - start
+    };
+  }
+  async ingestAll(designDir) {
+    const start = Date.now();
+    const [tokensResult, intentResult] = await Promise.all([
+      this.ingestTokens(path5.join(designDir, "tokens.json")),
+      this.ingestDesignIntent(path5.join(designDir, "DESIGN.md"))
+    ]);
+    const merged = mergeResults(tokensResult, intentResult);
+    return { ...merged, durationMs: Date.now() - start };
+  }
+};
+
+// src/constraints/DesignConstraintAdapter.ts
+var DesignConstraintAdapter = class {
+  constructor(store) {
+    this.store = store;
+  }
+  checkForHardcodedColors(source, file, strictness) {
+    const severity = this.mapSeverity(strictness);
+    const tokenNodes = this.store.findNodes({ type: "design_token" });
+    const colorValues = /* @__PURE__ */ new Set();
+    for (const node of tokenNodes) {
+      if (node.metadata.tokenType === "color" && typeof node.metadata.value === "string") {
+        colorValues.add(node.metadata.value.toLowerCase());
+      }
+    }
+    const hexPattern = /#[0-9a-fA-F]{3,8}\b/g;
+    const violations = [];
+    let match;
+    while ((match = hexPattern.exec(source)) !== null) {
+      const hexValue = match[0];
+      if (!colorValues.has(hexValue.toLowerCase())) {
+        violations.push({
+          code: "DESIGN-001",
+          file,
+          message: `Hardcoded color ${hexValue} is not in the design token set`,
+          severity,
+          value: hexValue
+        });
+      }
+    }
+    return violations;
+  }
+  checkForHardcodedFonts(source, file, strictness) {
+    const severity = this.mapSeverity(strictness);
+    const tokenNodes = this.store.findNodes({ type: "design_token" });
+    const fontFamilies = /* @__PURE__ */ new Set();
+    for (const node of tokenNodes) {
+      if (node.metadata.tokenType === "typography") {
+        const value = node.metadata.value;
+        if (typeof value === "object" && value !== null && "fontFamily" in value) {
+          fontFamilies.add(value.fontFamily.toLowerCase());
+        }
+      }
+    }
+    const fontPatterns = [/fontFamily:\s*['"]([^'"]+)['"]/g, /font-family:\s*['"]([^'"]+)['"]/g];
+    const violations = [];
+    const seen = /* @__PURE__ */ new Set();
+    for (const pattern of fontPatterns) {
+      let match;
+      while ((match = pattern.exec(source)) !== null) {
+        const fontName = match[1];
+        if (seen.has(fontName.toLowerCase())) continue;
+        seen.add(fontName.toLowerCase());
+        if (!fontFamilies.has(fontName.toLowerCase())) {
+          violations.push({
+            code: "DESIGN-002",
+            file,
+            message: `Hardcoded font family "${fontName}" is not in the design token set`,
+            severity,
+            value: fontName
+          });
+        }
+      }
+    }
+    return violations;
+  }
+  checkAll(source, file, strictness) {
+    return [
+      ...this.checkForHardcodedColors(source, file, strictness),
+      ...this.checkForHardcodedFonts(source, file, strictness)
+    ];
+  }
+  mapSeverity(strictness = "standard") {
+    switch (strictness) {
+      case "permissive":
+        return "info";
+      case "standard":
+        return "warn";
+      case "strict":
+        return "error";
+    }
+  }
+};
+
 // src/feedback/GraphFeedbackAdapter.ts
 var GraphFeedbackAdapter = class {
   constructor(store) {
@@ -2351,7 +2828,7 @@ var GraphFeedbackAdapter = class {
 };
 
 // src/index.ts
-var VERSION = "0.1.0";
+var VERSION = "0.2.0";
 export {
   Assembler,
   CIConnector,
@@ -2359,10 +2836,14 @@ export {
   CodeIngestor,
   ConfluenceConnector,
   ContextQL,
+  DesignConstraintAdapter,
+  DesignIngestor,
   EDGE_TYPES,
   FusionLayer,
   GitIngestor,
+  GraphComplexityAdapter,
   GraphConstraintAdapter,
+  GraphCouplingAdapter,
   GraphEdgeSchema,
   GraphEntropyAdapter,
   GraphFeedbackAdapter,