@harness-engineering/graph 0.11.1 → 0.11.3

package/dist/index.mjs

@@ -3857,29 +3857,41 @@ var KnowledgeLinker = class {
 // src/ingest/StructuralDriftDetector.ts
 var StructuralDriftDetector = class {
   detect(current, fresh) {
-    const findings = [];
     const currentById = new Map(current.entries.map((e) => [e.id, e]));
     const freshById = new Map(fresh.entries.map((e) => [e.id, e]));
+    const findings = [
+      ...this.findNew(currentById, freshById),
+      ...this.findStale(currentById, freshById),
+      ...this.findDrifted(currentById, freshById)
+    ];
+    findings.push(...this.findContradicting(fresh.entries, findings));
+    const totalEntries = (/* @__PURE__ */ new Set([...currentById.keys(), ...freshById.keys()])).size;
+    const driftScore = totalEntries > 0 ? findings.length / totalEntries : 0;
+    return { findings, driftScore, summary: this.summarize(findings) };
+  }
+  /** 1. NEW: entries in fresh but not in current */
+  findNew(currentById, freshById) {
+    const findings = [];
     for (const [id, entry] of freshById) {
       if (!currentById.has(id)) {
-        findings.push({
-          entryId: id,
-          classification: "new",
-          fresh: entry,
-          severity: "low"
-        });
+        findings.push({ entryId: id, classification: "new", fresh: entry, severity: "low" });
       }
     }
+    return findings;
+  }
+  /** 2. STALE: entries in current but not in fresh */
+  findStale(currentById, freshById) {
+    const findings = [];
     for (const [id, entry] of currentById) {
       if (!freshById.has(id)) {
-        findings.push({
-          entryId: id,
-          classification: "stale",
-          current: entry,
-          severity: "high"
-        });
+        findings.push({ entryId: id, classification: "stale", current: entry, severity: "high" });
       }
     }
+    return findings;
+  }
+  /** 3. DRIFTED: entries in both but contentHash differs */
+  findDrifted(currentById, freshById) {
+    const findings = [];
     for (const [id, freshEntry] of freshById) {
       const currentEntry = currentById.get(id);
       if (currentEntry && currentEntry.contentHash !== freshEntry.contentHash) {
@@ -3892,43 +3904,56 @@ var StructuralDriftDetector = class {
         });
       }
     }
+    return findings;
+  }
+  /** 4. CONTRADICTING: same entity name from different sources with different content */
+  findContradicting(entries, existing) {
+    const result = [];
+    const alreadyContradicting = new Set(
+      existing.filter((f) => f.classification === "contradicting").map((f) => f.entryId)
+    );
+    for (const [, group] of this.groupByName(entries)) {
+      const finding = this.contradictionForGroup(group, alreadyContradicting);
+      if (finding) {
+        result.push(finding);
+        alreadyContradicting.add(finding.entryId);
+      }
+    }
+    return result;
+  }
+  groupByName(entries) {
     const byName = /* @__PURE__ */ new Map();
-    for (const entry of fresh.entries) {
+    for (const entry of entries) {
       const group = byName.get(entry.name) ?? [];
       group.push(entry);
       byName.set(entry.name, group);
     }
-    for (const [, group] of byName) {
-      if (group.length > 1) {
-        const sources = new Set(group.map((e) => e.source));
-        const hashes = new Set(group.map((e) => e.contentHash));
-        if (sources.size > 1 && hashes.size > 1) {
-          const alreadyContradicting = new Set(
-            findings.filter((f) => f.classification === "contradicting").map((f) => f.entryId)
-          );
-          for (const entry of group) {
-            if (!alreadyContradicting.has(entry.id)) {
-              findings.push({
-                entryId: entry.id,
-                classification: "contradicting",
-                fresh: entry,
-                severity: "critical"
-              });
-              break;
-            }
-          }
-        }
+    return byName;
+  }
+  contradictionForGroup(group, alreadyContradicting) {
+    if (group.length <= 1) return void 0;
+    const sources = new Set(group.map((e) => e.source));
+    const hashes = new Set(group.map((e) => e.contentHash));
+    if (sources.size <= 1 || hashes.size <= 1) return void 0;
+    for (const entry of group) {
+      if (!alreadyContradicting.has(entry.id)) {
+        return {
+          entryId: entry.id,
+          classification: "contradicting",
+          fresh: entry,
+          severity: "critical"
+        };
       }
     }
-    const totalEntries = (/* @__PURE__ */ new Set([...currentById.keys(), ...freshById.keys()])).size;
-    const driftScore = totalEntries > 0 ? findings.length / totalEntries : 0;
-    const summary = {
+    return void 0;
+  }
+  summarize(findings) {
+    return {
       new: findings.filter((f) => f.classification === "new").length,
       drifted: findings.filter((f) => f.classification === "drifted").length,
       stale: findings.filter((f) => f.classification === "stale").length,
       contradicting: findings.filter((f) => f.classification === "contradicting").length
     };
-    return { findings, driftScore, summary };
   }
 };
 
@@ -3977,6 +4002,29 @@ var KnowledgeStagingAggregator = class {
     return titleMatch ? titleMatch[1].trim() : path9.basename(filePath, ".md");
   }
   async generateGapReport(knowledgeDir, store) {
+    const { domainDocNames, domainEntryCounts, totalEntries } = await this.collectDocumentedEntries(
+      knowledgeDir,
+      store
+    );
+    if (!store) {
+      return this.buildEntryOnlyReport(domainEntryCounts, totalEntries);
+    }
+    const extractedByDomain = this.collectExtractedByDomain(store);
+    const { domains, totalExtracted, totalGaps } = this.buildDomainCoverage(
+      domainEntryCounts,
+      extractedByDomain,
+      domainDocNames
+    );
+    return {
+      domains,
+      totalEntries,
+      totalExtracted,
+      totalGaps,
+      generatedAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+  }
+  /** Step 1-2: count `.md` entries per domain, capturing normalized names when a store is present. */
+  async collectDocumentedEntries(knowledgeDir, store) {
     const domainDocNames = /* @__PURE__ */ new Map();
     const domainEntryCounts = /* @__PURE__ */ new Map();
     let totalEntries = 0;
@@ -3987,33 +4035,41 @@ var KnowledgeStagingAggregator = class {
         const domainPath = path9.join(knowledgeDir, dir.name);
         const files = await fs8.readdir(domainPath);
         const mdFiles = files.filter((f) => f.endsWith(".md"));
-        const entryCount = mdFiles.length;
-        totalEntries += entryCount;
-        domainEntryCounts.set(dir.name, entryCount);
+        totalEntries += mdFiles.length;
+        domainEntryCounts.set(dir.name, mdFiles.length);
         if (store) {
-          const names = [];
-          for (const file of mdFiles) {
-            const name = await this.extractDocName(path9.join(domainPath, file));
-            names.push(name.toLowerCase().trim());
-          }
-          domainDocNames.set(dir.name, names);
+          domainDocNames.set(dir.name, await this.extractDocNames(domainPath, mdFiles));
         }
       }
     } catch {
     }
-    if (!store) {
-      const domains2 = [];
-      for (const [domain, entryCount] of domainEntryCounts) {
-        domains2.push({ domain, entryCount, extractedCount: 0, gapCount: 0, gapEntries: [] });
-      }
-      return {
-        domains: domains2,
-        totalEntries,
-        totalExtracted: 0,
-        totalGaps: 0,
-        generatedAt: (/* @__PURE__ */ new Date()).toISOString()
-      };
+    return { domainDocNames, domainEntryCounts, totalEntries };
+  }
+  /** Extract and normalize the documented title from each markdown file in a domain. */
+  async extractDocNames(domainPath, mdFiles) {
+    const names = [];
+    for (const file of mdFiles) {
+      const name = await this.extractDocName(path9.join(domainPath, file));
+      names.push(name.toLowerCase().trim());
     }
+    return names;
+  }
+  /** Step 3: backward-compatible report when no store is available. */
+  buildEntryOnlyReport(domainEntryCounts, totalEntries) {
+    const domains = [];
+    for (const [domain, entryCount] of domainEntryCounts) {
+      domains.push({ domain, entryCount, extractedCount: 0, gapCount: 0, gapEntries: [] });
+    }
+    return {
+      domains,
+      totalEntries,
+      totalExtracted: 0,
+      totalGaps: 0,
+      generatedAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+  }
+  /** Step 4: query store for all business nodes, group by domain, deduplicate by name. */
+  collectExtractedByDomain(store) {
     const extractedByDomain = /* @__PURE__ */ new Map();
     for (const nodeType of BUSINESS_NODE_TYPES) {
       const nodes = store.findNodes({ type: nodeType });
@@ -4025,15 +4081,22 @@ var KnowledgeStagingAggregator = class {
       }
     }
     for (const [domain, nodes] of extractedByDomain) {
-      const seen = /* @__PURE__ */ new Set();
-      const deduped = nodes.filter((n) => {
-        const key = n.name.toLowerCase().trim();
-        if (seen.has(key)) return false;
-        seen.add(key);
-        return true;
-      });
-      extractedByDomain.set(domain, deduped);
+      extractedByDomain.set(domain, this.dedupeByName(nodes));
     }
+    return extractedByDomain;
+  }
+  /** Keep the first occurrence of each normalized name, preserving order. */
+  dedupeByName(nodes) {
+    const seen = /* @__PURE__ */ new Set();
+    return nodes.filter((n) => {
+      const key = n.name.toLowerCase().trim();
+      if (seen.has(key)) return false;
+      seen.add(key);
+      return true;
+    });
+  }
+  /** Step 5: build per-domain coverage with gap analysis and roll up totals. */
+  buildDomainCoverage(domainEntryCounts, extractedByDomain, domainDocNames) {
     const allDomains = /* @__PURE__ */ new Set([...domainEntryCounts.keys(), ...extractedByDomain.keys()]);
     const domains = [];
     let totalExtracted = 0;
@@ -4044,29 +4107,28 @@ var KnowledgeStagingAggregator = class {
       const extractedCount = extractedNodes.length;
       totalExtracted += extractedCount;
       const docNames = domainDocNames.get(domain) ?? [];
-      const gapEntries = [];
-      for (const node of extractedNodes) {
-        const normalizedName = node.name.toLowerCase().trim();
-        if (!docNames.includes(normalizedName)) {
-          gapEntries.push({
-            nodeId: node.id,
-            name: node.name,
-            nodeType: node.type,
-            source: node.metadata?.source ?? "unknown",
-            hasContent: Boolean(node.content && node.content.trim().length >= 10)
-          });
-        }
-      }
+      const gapEntries = this.computeGapEntries(extractedNodes, docNames);
       totalGaps += gapEntries.length;
       domains.push({ domain, entryCount, extractedCount, gapCount: gapEntries.length, gapEntries });
     }
-    return {
-      domains,
-      totalEntries,
-      totalExtracted,
-      totalGaps,
-      generatedAt: (/* @__PURE__ */ new Date()).toISOString()
-    };
+    return { domains, totalExtracted, totalGaps };
+  }
+  /** Collect extracted nodes that have no matching documented name. */
+  computeGapEntries(extractedNodes, docNames) {
+    const gapEntries = [];
+    for (const node of extractedNodes) {
+      const normalizedName = node.name.toLowerCase().trim();
+      if (!docNames.includes(normalizedName)) {
+        gapEntries.push({
+          nodeId: node.id,
+          name: node.name,
+          nodeType: node.type,
+          source: node.metadata?.source ?? "unknown",
+          hasContent: Boolean(node.content && node.content.trim().length >= 10)
+        });
+      }
+    }
+    return gapEntries;
   }
   async writeGapReport(report) {
     const gapsDir = path9.join(this.projectDir, ".harness", "knowledge");
@@ -4313,6 +4375,9 @@ var PATTERNS = {
     /@Test\s*\n\s*(?:public\s+|private\s+|protected\s+)?(?:static\s+)?(?:void|[\w<>]+)\s+(\w+)\s*\(/g
   ]
 };
+var RUST_FN_RE = /(?:pub\s+)?(?:async\s+)?fn\s+(\w+)/;
+var JAVA_DISPLAY_RE = /@DisplayName\s*\(\s*"([^"]+)"\s*\)/;
+var JAVA_METHOD_RE = /^\s*(?:(?:public|private|protected)\s+)?(?:static\s+)?(?:void|[\w<>[\]]+)\s+(\w+)\s*\(/;
 var TestDescriptionExtractor = class {
   name = "test-descriptions";
   supportedExtensions = [".ts", ".tsx", ".js", ".jsx", ".py", ".go", ".rs", ".java"];
@@ -4342,83 +4407,87 @@ var TestDescriptionExtractor = class {
     const records = [];
     const describeStack = [];
     for (let i = 0; i < lines.length; i++) {
-      const line = lines[i];
-      const describeMatch = line.match(/describe\s*\(\s*(['"`])((?:(?!\1).)*)\1/);
-      if (describeMatch) {
-        describeStack.push(describeMatch[2]);
-      }
-      const itMatch = line.match(/(?:it|test)\s*\(\s*(['"`])((?:(?!\1).)*)\1/);
-      if (itMatch) {
-        const testName = itMatch[2];
-        const fullPath = [...describeStack, testName].join(" > ");
-        const patternKey = fullPath;
-        records.push({
-          id: `extracted:test-descriptions:${hash(filePath + ":" + patternKey)}`,
-          extractor: "test-descriptions",
-          language,
-          filePath,
-          line: i + 1,
-          nodeType: "business_rule",
-          name: testName,
-          content: fullPath,
-          confidence: 0.7,
-          metadata: {
-            suite: describeStack.length > 0 ? describeStack[describeStack.length - 1] : void 0,
-            framework: "vitest"
-          }
-        });
-      }
-      if (line.match(/^\s*\}\s*\)\s*;?\s*$/) && describeStack.length > 0) {
-        describeStack.pop();
-      }
+      this.scanJsTsLine(lines[i], i, language, filePath, describeStack, records);
     }
     return records;
   }
+  scanJsTsLine(line, index, language, filePath, describeStack, records) {
+    const describeMatch = line.match(/describe\s*\(\s*(['"`])((?:(?!\1).)*)\1/);
+    if (describeMatch) describeStack.push(describeMatch[2]);
+    const itMatch = line.match(/(?:it|test)\s*\(\s*(['"`])((?:(?!\1).)*)\1/);
+    if (itMatch) {
+      records.push(this.buildJsTsRecord(itMatch[2], index, language, filePath, describeStack));
+    }
+    if (/^\s*\}\s*\)\s*;?\s*$/.test(line) && describeStack.length > 0) describeStack.pop();
+  }
+  buildJsTsRecord(testName, index, language, filePath, describeStack) {
+    const fullPath = [...describeStack, testName].join(" > ");
+    const patternKey = fullPath;
+    return {
+      id: `extracted:test-descriptions:${hash(filePath + ":" + patternKey)}`,
+      extractor: "test-descriptions",
+      language,
+      filePath,
+      line: index + 1,
+      nodeType: "business_rule",
+      name: testName,
+      content: fullPath,
+      confidence: 0.7,
+      metadata: {
+        suite: describeStack.length > 0 ? describeStack[describeStack.length - 1] : void 0,
+        framework: "vitest"
+      }
+    };
+  }
   extractPython(_content, filePath, language, lines) {
     const records = [];
     let currentClass;
     for (let i = 0; i < lines.length; i++) {
       const line = lines[i];
       const classMatch = line.match(/^class\s+(Test\w+)/);
-      if (classMatch) {
-        currentClass = classMatch[1];
-      }
+      if (classMatch) currentClass = classMatch[1];
       const funcMatch = line.match(/^\s*def\s+(test_\w+)\s*\(/);
       if (funcMatch) {
-        const testName = funcMatch[1];
-        const humanName = testName.replace(/^test_/, "").replace(/_/g, " ");
-        let docstring;
-        if (i + 1 < lines.length) {
-          const nextLine = lines[i + 1].trim();
-          const docMatch = nextLine.match(/^"""(.+?)"""/);
-          if (docMatch) {
-            docstring = docMatch[1];
-          }
-        }
-        const patternKey = currentClass ? `${currentClass}.${testName}` : testName;
-        records.push({
-          id: `extracted:test-descriptions:${hash(filePath + ":" + patternKey)}`,
-          extractor: "test-descriptions",
-          language,
-          filePath,
-          line: i + 1,
-          nodeType: "business_rule",
-          name: docstring ?? humanName,
-          content: patternKey,
-          confidence: docstring ? 0.7 : 0.5,
-          metadata: {
-            suite: currentClass,
-            framework: "pytest",
-            functionName: testName
-          }
-        });
-      }
-      if (currentClass && /^\S/.test(line) && !line.startsWith("class ") && !line.startsWith("#") && line.trim() !== "") {
-        currentClass = void 0;
+        records.push(
+          this.buildPythonRecord(funcMatch[1], i, language, filePath, currentClass, lines)
+        );
       }
+      if (this.isPythonClassReset(line, currentClass)) currentClass = void 0;
     }
     return records;
   }
+  isPythonClassReset(line, currentClass) {
+    return Boolean(
+      currentClass && /^\S/.test(line) && !line.startsWith("class ") && !line.startsWith("#") && line.trim() !== ""
+    );
+  }
+  findPythonDocstring(lines, index) {
+    if (index + 1 >= lines.length) return void 0;
+    const nextLine = lines[index + 1].trim();
+    const docMatch = nextLine.match(/^"""(.+?)"""/);
+    return docMatch ? docMatch[1] : void 0;
+  }
+  buildPythonRecord(testName, index, language, filePath, currentClass, lines) {
+    const humanName = testName.replace(/^test_/, "").replace(/_/g, " ");
+    const docstring = this.findPythonDocstring(lines, index);
+    const patternKey = currentClass ? `${currentClass}.${testName}` : testName;
+    return {
+      id: `extracted:test-descriptions:${hash(filePath + ":" + patternKey)}`,
+      extractor: "test-descriptions",
+      language,
+      filePath,
+      line: index + 1,
+      nodeType: "business_rule",
+      name: docstring ?? humanName,
+      content: patternKey,
+      confidence: docstring ? 0.7 : 0.5,
+      metadata: {
+        suite: currentClass,
+        framework: "pytest",
+        functionName: testName
+      }
+    };
+  }
   extractGo(_content, filePath, language, lines) {
     const records = [];
     let currentTest;
@@ -4467,89 +4536,107 @@ var TestDescriptionExtractor = class {
   extractRust(_content, filePath, language, lines) {
     const records = [];
     for (let i = 0; i < lines.length; i++) {
-      const line = lines[i];
-      if (line.trim() === "#[test]") {
-        for (let j = i + 1; j < lines.length && j <= i + 3; j++) {
-          const fnLine = lines[j];
-          const fnMatch = fnLine.match(/(?:pub\s+)?(?:async\s+)?fn\s+(\w+)/);
-          if (fnMatch) {
-            const testName = fnMatch[1];
-            const humanName = testName.replace(/^test_/, "").replace(/_/g, " ");
-            let docComment;
-            if (i > 0) {
-              const prevLine = lines[i - 1].trim();
-              const docMatch = prevLine.match(/^\/\/\/\s*(.+)/);
-              if (docMatch) {
-                docComment = docMatch[1];
-              }
-            }
-            records.push({
-              id: `extracted:test-descriptions:${hash(filePath + ":" + testName)}`,
-              extractor: "test-descriptions",
-              language,
-              filePath,
-              line: j + 1,
-              nodeType: "business_rule",
-              name: docComment ?? humanName,
-              content: testName,
-              confidence: docComment ? 0.7 : 0.5,
-              metadata: { framework: "rust-test" }
-            });
-            break;
-          }
-        }
-      }
+      if (lines[i].trim() !== "#[test]") continue;
+      const record = this.buildRustRecord(lines, i, language, filePath);
+      if (record) records.push(record);
     }
     return records;
   }
+  buildRustRecord(lines, testIdx, language, filePath) {
+    for (let j = testIdx + 1; j < lines.length && j <= testIdx + 3; j++) {
+      const fnMatch = lines[j].match(RUST_FN_RE);
+      if (!fnMatch) continue;
+      const testName = fnMatch[1];
+      const humanName = testName.replace(/^test_/, "").replace(/_/g, " ");
+      const docComment = this.findRustDocComment(lines, testIdx);
+      return {
+        id: `extracted:test-descriptions:${hash(filePath + ":" + testName)}`,
+        extractor: "test-descriptions",
+        language,
+        filePath,
+        line: j + 1,
+        nodeType: "business_rule",
+        name: docComment ?? humanName,
+        content: testName,
+        confidence: docComment ? 0.7 : 0.5,
+        metadata: { framework: "rust-test" }
+      };
+    }
+    return void 0;
+  }
+  findRustDocComment(lines, testIdx) {
+    if (testIdx <= 0) return void 0;
+    const prevLine = lines[testIdx - 1].trim();
+    const docMatch = prevLine.match(/^\/\/\/\s*(.+)/);
+    return docMatch ? docMatch[1] : void 0;
+  }
   extractJava(_content, filePath, language, lines) {
     const records = [];
     for (let i = 0; i < lines.length; i++) {
-      const line = lines[i];
-      const testMatch = line.match(/@Test\s*$/);
-      if (testMatch) {
-        let displayName;
-        for (let k = Math.max(0, i - 3); k < i; k++) {
-          const prevLine = lines[k];
-          const dm = prevLine.match(/@DisplayName\s*\(\s*"([^"]+)"\s*\)/);
-          if (dm) displayName = dm[1];
-        }
-        for (let j = i + 1; j < lines.length && j <= i + 5; j++) {
-          const scanLine = lines[j];
-          const adjacentDisplay = scanLine.match(/@DisplayName\s*\(\s*"([^"]+)"\s*\)/);
-          if (adjacentDisplay) {
-            displayName = adjacentDisplay[1];
-            continue;
-          }
-          const methodMatch = scanLine.match(
-            /^\s*(?:(?:public|private|protected)\s+)?(?:static\s+)?(?:void|[\w<>[\]]+)\s+(\w+)\s*\(/
-          );
-          if (methodMatch) {
-            const methodName = methodMatch[1];
-            const name = displayName ?? methodName;
-            const patternKey = displayName ?? methodName;
-            records.push({
-              id: `extracted:test-descriptions:${hash(filePath + ":" + patternKey)}`,
-              extractor: "test-descriptions",
-              language,
-              filePath,
-              line: j + 1,
-              nodeType: "business_rule",
-              name,
-              content: patternKey,
-              confidence: displayName ? 0.7 : 0.5,
-              metadata: { framework: "junit5" }
-            });
-            break;
-          }
-        }
-      }
+      if (!/@Test\s*$/.test(lines[i])) continue;
+      const record = this.buildJavaRecord(lines, i, language, filePath);
+      if (record) records.push(record);
     }
     return records;
   }
+  buildJavaRecord(lines, testIdx, language, filePath) {
+    let displayName = this.findJavaDisplayNameBefore(lines, testIdx);
+    for (let j = testIdx + 1; j < lines.length && j <= testIdx + 5; j++) {
+      const scanLine = lines[j];
+      const adjacentDisplay = scanLine.match(JAVA_DISPLAY_RE);
+      if (adjacentDisplay) {
+        displayName = adjacentDisplay[1];
+        continue;
+      }
+      const methodMatch = scanLine.match(JAVA_METHOD_RE);
+      if (methodMatch) {
+        return this.buildJavaRecordFromMethod(methodMatch[1], displayName, j, language, filePath);
+      }
+    }
+    return void 0;
+  }
+  findJavaDisplayNameBefore(lines, testIdx) {
+    let displayName;
+    for (let k = Math.max(0, testIdx - 3); k < testIdx; k++) {
+      const dm = lines[k].match(JAVA_DISPLAY_RE);
+      if (dm) displayName = dm[1];
+    }
+    return displayName;
+  }
+  buildJavaRecordFromMethod(methodName, displayName, index, language, filePath) {
+    const name = displayName ?? methodName;
+    const patternKey = displayName ?? methodName;
+    return {
+      id: `extracted:test-descriptions:${hash(filePath + ":" + patternKey)}`,
+      extractor: "test-descriptions",
+      language,
+      filePath,
+      line: index + 1,
+      nodeType: "business_rule",
+      name,
+      content: patternKey,
+      confidence: displayName ? 0.7 : 0.5,
+      metadata: { framework: "junit5" }
+    };
+  }
 };
 
 // src/ingest/extractors/EnumConstantExtractor.ts
+var TS_ENUM_RE = /(?:export\s+)?enum\s+(\w+)/;
+var TS_AS_CONST_RE = /(?:export\s+)?const\s+(\w+)\s*=\s*\{/;
+var TS_UNION_RE = /(?:export\s+)?type\s+(\w+)\s*=\s*(['"`][\w]+['"`](?:\s*\|\s*['"`][\w]+['"`])+)/;
+var JS_FREEZE_RE = /(?:export\s+)?const\s+(\w+)\s*=\s*Object\.freeze\s*\(\s*\{/;
+var JS_CONST_OBJECT_RE = /(?:export\s+)?const\s+([A-Z][A-Z_\d]*)\s*=\s*\{/;
+var JS_UPPER_KEY_RE = /^[A-Z][A-Z_\d]*$/;
+var PY_ENUM_RE = /^class\s+(\w+)\s*\(\s*(?:str\s*,\s*)?(?:Enum|StrEnum|IntEnum|Flag|IntFlag)\s*\)/;
+var PY_LITERAL_RE = /(\w+)\s*=\s*Literal\s*\[([^\]]+)\]/;
+var GO_TYPE_RE = /^type\s+(\w+)\s+(?:int|string|uint|int32|int64|uint32|uint64)/;
+var GO_CONST_BLOCK_RE = /^const\s*\(/;
+var GO_IOTA_RE = /^(\w+)\s+(\w+)\s*=\s*iota/;
+var GO_TYPED_RE = /^(\w+)\s+(\w+)\s*=\s*"[^"]*"/;
+var GO_BARE_RE = /^(\w+)\s*$/;
+var RUST_ENUM_RE = /^(?:pub\s+)?enum\s+(\w+)/;
+var JAVA_ENUM_RE = /(?:public\s+|private\s+|protected\s+)?enum\s+(\w+)/;
 var EnumConstantExtractor = class {
   name = "enum-constants";
   supportedExtensions = [".ts", ".tsx", ".js", ".jsx", ".py", ".go", ".rs", ".java"];
@@ -4573,213 +4660,235 @@ var EnumConstantExtractor = class {
     const records = [];
     const lines = content.split("\n");
     for (let i = 0; i < lines.length; i++) {
-      const line = lines[i];
-      const enumMatch = line.match(/(?:export\s+)?enum\s+(\w+)/);
-      if (enumMatch) {
-        const enumName = enumMatch[1];
-        const members = this.collectEnumMembers(lines, i + 1);
-        records.push({
-          id: `extracted:enum-constants:${hash(filePath + ":" + enumName)}`,
-          extractor: "enum-constants",
-          language,
-          filePath,
-          line: i + 1,
-          nodeType: "business_term",
-          name: enumName,
-          content: `enum ${enumName} { ${members.join(", ")} }`,
-          confidence: 0.8,
-          metadata: { kind: "enum", members }
-        });
-      }
-      const constMatch = line.match(/(?:export\s+)?const\s+(\w+)\s*=\s*\{/);
-      if (constMatch && content.includes("as const")) {
-        const blockEnd = this.findClosingBrace(lines, i);
-        const block = lines.slice(i, blockEnd + 1).join("\n");
-        if (block.includes("as const")) {
-          const constName = constMatch[1];
-          const members = this.collectObjectKeys(lines, i + 1);
-          records.push({
-            id: `extracted:enum-constants:${hash(filePath + ":" + constName)}`,
-            extractor: "enum-constants",
-            language,
-            filePath,
-            line: i + 1,
-            nodeType: "business_term",
-            name: constName,
-            content: `const ${constName} = { ${members.join(", ")} } as const`,
-            confidence: 0.8,
-            metadata: { kind: "as-const", members }
-          });
-        }
-      }
-      const unionMatch = line.match(
-        /(?:export\s+)?type\s+(\w+)\s*=\s*(['"`][\w]+['"`](?:\s*\|\s*['"`][\w]+['"`])+)/
-      );
-      if (unionMatch) {
-        const typeName = unionMatch[1];
-        const values = unionMatch[2].split("|").map((v) => v.trim().replace(/['"`]/g, ""));
-        records.push({
-          id: `extracted:enum-constants:${hash(filePath + ":" + typeName)}`,
-          extractor: "enum-constants",
-          language,
-          filePath,
-          line: i + 1,
-          nodeType: "business_term",
-          name: typeName,
-          content: `type ${typeName} = ${values.map((v) => `'${v}'`).join(" | ")}`,
-          confidence: 0.7,
-          metadata: { kind: "union-type", members: values }
-        });
-      }
+      const enumRecord = this.matchTsEnum(lines, i, filePath, language);
+      if (enumRecord) records.push(enumRecord);
+      const asConstRecord = this.matchTsAsConst(content, lines, i, filePath, language);
+      if (asConstRecord) records.push(asConstRecord);
+      const unionRecord = this.matchTsUnion(lines, i, filePath, language);
+      if (unionRecord) records.push(unionRecord);
     }
     return records;
   }
+  matchTsEnum(lines, i, filePath, language) {
+    const enumMatch = lines[i].match(TS_ENUM_RE);
+    if (!enumMatch) return void 0;
+    const enumName = enumMatch[1];
+    const members = this.collectEnumMembers(lines, i + 1);
+    return {
+      id: `extracted:enum-constants:${hash(filePath + ":" + enumName)}`,
+      extractor: "enum-constants",
+      language,
+      filePath,
+      line: i + 1,
+      nodeType: "business_term",
+      name: enumName,
+      content: `enum ${enumName} { ${members.join(", ")} }`,
+      confidence: 0.8,
+      metadata: { kind: "enum", members }
+    };
+  }
+  matchTsAsConst(content, lines, i, filePath, language) {
+    const constMatch = lines[i].match(TS_AS_CONST_RE);
+    if (!constMatch || !content.includes("as const")) return void 0;
+    const blockEnd = this.findClosingBrace(lines, i);
+    const block = lines.slice(i, blockEnd + 1).join("\n");
+    if (!block.includes("as const")) return void 0;
+    const constName = constMatch[1];
+    const members = this.collectObjectKeys(lines, i + 1);
+    return {
+      id: `extracted:enum-constants:${hash(filePath + ":" + constName)}`,
+      extractor: "enum-constants",
+      language,
+      filePath,
+      line: i + 1,
+      nodeType: "business_term",
+      name: constName,
+      content: `const ${constName} = { ${members.join(", ")} } as const`,
+      confidence: 0.8,
+      metadata: { kind: "as-const", members }
+    };
+  }
+  matchTsUnion(lines, i, filePath, language) {
+    const unionMatch = lines[i].match(TS_UNION_RE);
+    if (!unionMatch) return void 0;
+    const typeName = unionMatch[1];
+    const values = unionMatch[2].split("|").map((v) => v.trim().replace(/['"`]/g, ""));
+    return {
+      id: `extracted:enum-constants:${hash(filePath + ":" + typeName)}`,
+      extractor: "enum-constants",
+      language,
+      filePath,
+      line: i + 1,
+      nodeType: "business_term",
+      name: typeName,
+      content: `type ${typeName} = ${values.map((v) => `'${v}'`).join(" | ")}`,
+      confidence: 0.7,
+      metadata: { kind: "union-type", members: values }
+    };
+  }
   extractJavaScript(content, filePath, language) {
     const records = [];
     const lines = content.split("\n");
     for (let i = 0; i < lines.length; i++) {
-      const line = lines[i];
-      const freezeMatch = line.match(/(?:export\s+)?const\s+(\w+)\s*=\s*Object\.freeze\s*\(\s*\{/);
+      const freezeMatch = lines[i].match(JS_FREEZE_RE);
       if (freezeMatch) {
-        const name = freezeMatch[1];
-        const members = this.collectObjectKeys(lines, i + 1);
-        records.push({
-          id: `extracted:enum-constants:${hash(filePath + ":" + name)}`,
-          extractor: "enum-constants",
-          language,
-          filePath,
-          line: i + 1,
-          nodeType: "business_term",
-          name,
-          content: `const ${name} = Object.freeze({ ${members.join(", ")} })`,
-          confidence: 0.8,
-          metadata: { kind: "frozen-object", members }
-        });
+        records.push(this.buildJsFreezeRecord(freezeMatch[1], lines, i, filePath, language));
       }
-      const constMatch = line.match(/(?:export\s+)?const\s+([A-Z][A-Z_\d]*)\s*=\s*\{/);
-      if (constMatch && !freezeMatch) {
-        const name = constMatch[1];
-        const members = this.collectObjectKeys(lines, i + 1);
-        if (members.length > 0 && members.every((m) => /^[A-Z][A-Z_\d]*$/.test(m))) {
-          records.push({
-            id: `extracted:enum-constants:${hash(filePath + ":" + name)}`,
-            extractor: "enum-constants",
-            language,
-            filePath,
-            line: i + 1,
-            nodeType: "business_term",
-            name,
-            content: `const ${name} = { ${members.join(", ")} }`,
-            confidence: 0.6,
-            metadata: { kind: "const-object", members }
-          });
-        }
+      if (!freezeMatch) {
+        const constRecord = this.matchJsConstObject(lines, i, filePath, language);
+        if (constRecord) records.push(constRecord);
       }
     }
     return records;
   }
+  buildJsFreezeRecord(name, lines, i, filePath, language) {
+    const members = this.collectObjectKeys(lines, i + 1);
+    return {
+      id: `extracted:enum-constants:${hash(filePath + ":" + name)}`,
+      extractor: "enum-constants",
+      language,
+      filePath,
+      line: i + 1,
+      nodeType: "business_term",
+      name,
+      content: `const ${name} = Object.freeze({ ${members.join(", ")} })`,
+      confidence: 0.8,
+      metadata: { kind: "frozen-object", members }
+    };
+  }
+  matchJsConstObject(lines, i, filePath, language) {
+    const constMatch = lines[i].match(JS_CONST_OBJECT_RE);
+    if (!constMatch) return void 0;
+    const name = constMatch[1];
+    const members = this.collectObjectKeys(lines, i + 1);
+    if (members.length === 0 || !members.every((m) => JS_UPPER_KEY_RE.test(m))) return void 0;
+    return {
+      id: `extracted:enum-constants:${hash(filePath + ":" + name)}`,
+      extractor: "enum-constants",
+      language,
+      filePath,
+      line: i + 1,
+      nodeType: "business_term",
+      name,
+      content: `const ${name} = { ${members.join(", ")} }`,
+      confidence: 0.6,
+      metadata: { kind: "const-object", members }
+    };
+  }
   extractPython(content, filePath, language) {
     const records = [];
     const lines = content.split("\n");
     for (let i = 0; i < lines.length; i++) {
-      const line = lines[i];
-      const enumMatch = line.match(
-        /^class\s+(\w+)\s*\(\s*(?:str\s*,\s*)?(?:Enum|StrEnum|IntEnum|Flag|IntFlag)\s*\)/
-      );
-      if (enumMatch) {
-        const enumName = enumMatch[1];
-        const members = this.collectPythonEnumMembers(lines, i + 1);
-        records.push({
-          id: `extracted:enum-constants:${hash(filePath + ":" + enumName)}`,
-          extractor: "enum-constants",
-          language,
-          filePath,
-          line: i + 1,
-          nodeType: "business_term",
-          name: enumName,
-          content: `class ${enumName}(Enum) { ${members.join(", ")} }`,
-          confidence: 0.8,
-          metadata: { kind: "enum", members }
-        });
-      }
-      const literalMatch = line.match(/(\w+)\s*=\s*Literal\s*\[([^\]]+)\]/);
-      if (literalMatch) {
-        const typeName = literalMatch[1];
-        const values = literalMatch[2].split(",").map((v) => v.trim().replace(/["']/g, ""));
-        records.push({
-          id: `extracted:enum-constants:${hash(filePath + ":" + typeName)}`,
-          extractor: "enum-constants",
-          language,
-          filePath,
-          line: i + 1,
-          nodeType: "business_term",
-          name: typeName,
-          content: `${typeName} = Literal[${values.map((v) => `"${v}"`).join(", ")}]`,
-          confidence: 0.7,
-          metadata: { kind: "literal-type", members: values }
-        });
-      }
+      const enumRecord = this.matchPythonEnum(lines, i, filePath, language);
+      if (enumRecord) records.push(enumRecord);
+      const literalRecord = this.matchPythonLiteral(lines, i, filePath, language);
+      if (literalRecord) records.push(literalRecord);
     }
     return records;
   }
+  matchPythonEnum(lines, i, filePath, language) {
+    const enumMatch = lines[i].match(PY_ENUM_RE);
+    if (!enumMatch) return void 0;
+    const enumName = enumMatch[1];
+    const members = this.collectPythonEnumMembers(lines, i + 1);
+    return {
+      id: `extracted:enum-constants:${hash(filePath + ":" + enumName)}`,
+      extractor: "enum-constants",
+      language,
+      filePath,
+      line: i + 1,
+      nodeType: "business_term",
+      name: enumName,
+      content: `class ${enumName}(Enum) { ${members.join(", ")} }`,
+      confidence: 0.8,
+      metadata: { kind: "enum", members }
+    };
+  }
+  matchPythonLiteral(lines, i, filePath, language) {
+    const literalMatch = lines[i].match(PY_LITERAL_RE);
+    if (!literalMatch) return void 0;
+    const typeName = literalMatch[1];
+    const values = literalMatch[2].split(",").map((v) => v.trim().replace(/["']/g, ""));
+    return {
+      id: `extracted:enum-constants:${hash(filePath + ":" + typeName)}`,
+      extractor: "enum-constants",
+      language,
+      filePath,
+      line: i + 1,
+      nodeType: "business_term",
+      name: typeName,
+      content: `${typeName} = Literal[${values.map((v) => `"${v}"`).join(", ")}]`,
+      confidence: 0.7,
+      metadata: { kind: "literal-type", members: values }
+    };
+  }
   extractGo(content, filePath, language) {
     const records = [];
     const lines = content.split("\n");
     for (let i = 0; i < lines.length; i++) {
       const line = lines[i];
-      const typeMatch = line.match(/^type\s+(\w+)\s+(?:int|string|uint|int32|int64|uint32|uint64)/);
+      const typeMatch = line.match(GO_TYPE_RE);
       if (typeMatch) {
       }
-      const constBlockMatch = line.match(/^const\s*\(/);
+      const constBlockMatch = line.match(GO_CONST_BLOCK_RE);
       if (constBlockMatch) {
-        const consts = [];
-        let typeName;
-        for (let j = i + 1; j < lines.length; j++) {
-          const constLine = lines[j].trim();
-          if (constLine === ")") break;
-          if (constLine === "" || constLine.startsWith("//")) continue;
-          const iotaMatch = constLine.match(/^(\w+)\s+(\w+)\s*=\s*iota/);
-          if (iotaMatch) {
-            typeName = iotaMatch[2];
-            consts.push(iotaMatch[1]);
-            continue;
-          }
-          const typedMatch = constLine.match(/^(\w+)\s+(\w+)\s*=\s*"[^"]*"/);
-          if (typedMatch) {
-            typeName = typeName ?? typedMatch[2];
-            consts.push(typedMatch[1]);
-            continue;
-          }
-          const bareMatch = constLine.match(/^(\w+)\s*$/);
-          if (bareMatch) {
-            consts.push(bareMatch[1]);
-          }
-        }
-        if (consts.length > 0) {
-          const name = typeName ?? consts[0];
-          records.push({
-            id: `extracted:enum-constants:${hash(filePath + ":" + name)}`,
-            extractor: "enum-constants",
-            language,
-            filePath,
-            line: i + 1,
-            nodeType: "business_term",
-            name,
-            content: `const ( ${consts.join(", ")} )`,
-            confidence: typeName ? 0.8 : 0.6,
-            metadata: { kind: typeName ? "typed-const" : "const-block", members: consts }
-          });
-        }
+        const record = this.buildGoConstBlockRecord(lines, i, filePath, language);
+        if (record) records.push(record);
       }
     }
     return records;
   }
+  buildGoConstBlockRecord(lines, i, filePath, language) {
+    const { consts, typeName } = this.collectGoConsts(lines, i + 1);
+    if (consts.length === 0) return void 0;
+    const name = typeName ?? consts[0];
+    return {
+      id: `extracted:enum-constants:${hash(filePath + ":" + name)}`,
+      extractor: "enum-constants",
+      language,
+      filePath,
+      line: i + 1,
+      nodeType: "business_term",
+      name,
+      content: `const ( ${consts.join(", ")} )`,
+      confidence: typeName ? 0.8 : 0.6,
+      metadata: { kind: typeName ? "typed-const" : "const-block", members: consts }
+    };
+  }
+  collectGoConsts(lines, startLine) {
+    const consts = [];
+    let typeName;
+    for (let j = startLine; j < lines.length; j++) {
+      const constLine = lines[j].trim();
+      if (constLine === ")") break;
+      if (constLine === "" || constLine.startsWith("//")) continue;
+      const parsed = this.parseGoConstLine(constLine);
+      if (!parsed) continue;
+      typeName = this.resolveGoTypeName(typeName, parsed);
+      consts.push(parsed.name);
+    }
+    return { consts, typeName };
+  }
+  parseGoConstLine(constLine) {
+    const iotaMatch = constLine.match(GO_IOTA_RE);
+    if (iotaMatch) return { name: iotaMatch[1], typeName: iotaMatch[2], overwriteType: true };
+    const typedMatch = constLine.match(GO_TYPED_RE);
+    if (typedMatch) return { name: typedMatch[1], typeName: typedMatch[2], overwriteType: false };
+    const bareMatch = constLine.match(GO_BARE_RE);
+    if (bareMatch) return { name: bareMatch[1] };
+    return void 0;
+  }
+  resolveGoTypeName(current, parsed) {
+    if (parsed.overwriteType) return parsed.typeName;
+    if (parsed.typeName !== void 0 && current === void 0) return parsed.typeName;
+    return current;
+  }
   extractRust(content, filePath, language) {
     const records = [];
     const lines = content.split("\n");
     for (let i = 0; i < lines.length; i++) {
       const line = lines[i];
-      const enumMatch = line.match(/^(?:pub\s+)?enum\s+(\w+)/);
+      const enumMatch = line.match(RUST_ENUM_RE);
       if (enumMatch) {
         const enumName = enumMatch[1];
         const members = this.collectRustEnumVariants(lines, i + 1);
@@ -4804,7 +4913,7 @@ var EnumConstantExtractor = class {
     const lines = content.split("\n");
     for (let i = 0; i < lines.length; i++) {
       const line = lines[i];
-      const enumMatch = line.match(/(?:public\s+|private\s+|protected\s+)?enum\s+(\w+)/);
+      const enumMatch = line.match(JAVA_ENUM_RE);
       if (enumMatch) {
         const enumName = enumMatch[1];
         const members = this.collectJavaEnumConstants(lines, i + 1);
@@ -4852,10 +4961,7 @@ var EnumConstantExtractor = class {
     for (let i = startLine; i < lines.length; i++) {
       for (const ch of lines[i]) {
         if (ch === "{") depth++;
-        if (ch === "}") {
-          depth--;
-          if (depth === 0) return i;
-        }
+        else if (ch === "}" && --depth === 0) return i;
       }
     }
     return lines.length - 1;
@@ -6216,34 +6322,42 @@ var KnowledgePipelineRunner = class {
 // src/ingest/connectors/ConnectorUtils.ts
 var CODE_NODE_TYPES5 = ["file", "function", "class", "method", "interface", "variable"];
 var RETRYABLE_STATUSES = /* @__PURE__ */ new Set([429, 500, 502, 503, 504]);
-function withRetry(client, options) {
-  const maxRetries = options?.maxRetries ?? 3;
-  const baseDelayMs = options?.baseDelayMs ?? 1e3;
-  const maxDelayMs = options?.maxDelayMs ?? 3e4;
-  return async (url, requestOptions) => {
-    let lastError;
-    for (let attempt = 0; attempt <= maxRetries; attempt++) {
-      try {
-        const response = await client(url, requestOptions);
-        if (response.ok || !RETRYABLE_STATUSES.has(response.status ?? 0)) {
-          return response;
-        }
-        if (attempt === maxRetries) {
-          return response;
-        }
-      } catch (err) {
-        lastError = err instanceof Error ? err : new Error(String(err));
-        if (attempt === maxRetries) {
-          throw lastError;
-        }
+function computeBackoffDelay(config, attempt) {
+  const exponentialDelay = config.baseDelayMs * 2 ** attempt;
+  const cappedDelay = Math.min(exponentialDelay, config.maxDelayMs);
+  return cappedDelay * (0.5 + Math.random() * 0.5);
+}
+function shouldReturnResponse(response, attempt, maxRetries) {
+  if (response.ok || !RETRYABLE_STATUSES.has(response.status ?? 0)) {
+    return true;
+  }
+  return attempt === maxRetries;
+}
+async function executeWithRetry(client, url, requestOptions, config) {
+  let lastError;
+  for (let attempt = 0; attempt <= config.maxRetries; attempt++) {
+    try {
+      const response = await client(url, requestOptions);
+      if (shouldReturnResponse(response, attempt, config.maxRetries)) {
+        return response;
+      }
+    } catch (err) {
+      lastError = err instanceof Error ? err : new Error(String(err));
+      if (attempt === config.maxRetries) {
+        throw lastError;
       }
-      const exponentialDelay = baseDelayMs * 2 ** attempt;
-      const cappedDelay = Math.min(exponentialDelay, maxDelayMs);
-      const jitteredDelay = cappedDelay * (0.5 + Math.random() * 0.5);
-      await new Promise((resolve) => setTimeout(resolve, jitteredDelay));
     }
-    throw lastError ?? new Error("Request failed after retries");
+    await new Promise((resolve) => setTimeout(resolve, computeBackoffDelay(config, attempt)));
+  }
+  throw lastError ?? new Error("Request failed after retries");
+}
+function withRetry(client, options) {
+  const config = {
+    maxRetries: options?.maxRetries ?? 3,
+    baseDelayMs: options?.baseDelayMs ?? 1e3,
+    maxDelayMs: options?.maxDelayMs ?? 3e4
   };
+  return (url, requestOptions) => executeWithRetry(client, url, requestOptions, config);
 }
 var SANITIZE_RULES = [
   // Strip XML/HTML-like instruction tags that could be interpreted as system prompts