@harness-engineering/graph 0.3.2 → 0.3.3

package/dist/index.mjs

@@ -357,6 +357,53 @@ var VectorStore = class _VectorStore {
 };
 
 // src/query/ContextQL.ts
+function edgeKey(e) {
+  return `${e.from}|${e.to}|${e.type}`;
+}
+function addEdge(state, edge) {
+  const key = edgeKey(edge);
+  if (!state.edgeSet.has(key)) {
+    state.edgeSet.add(key);
+    state.resultEdges.push(edge);
+  }
+}
+function shouldPruneNode(neighbor, pruneObservability, params) {
+  if (pruneObservability && OBSERVABILITY_TYPES.has(neighbor.type)) return true;
+  if (params.includeTypes && !params.includeTypes.includes(neighbor.type)) return true;
+  if (params.excludeTypes && params.excludeTypes.includes(neighbor.type)) return true;
+  return false;
+}
+function isEdgeExcluded(edge, params) {
+  return !!(params.includeEdges && !params.includeEdges.includes(edge.type));
+}
+function processNeighbor(store, edge, neighborId, nextDepth, queue, state, pruneObservability, params) {
+  if (isEdgeExcluded(edge, params)) return;
+  if (state.visited.has(neighborId)) {
+    addEdge(state, edge);
+    return;
+  }
+  const neighbor = store.getNode(neighborId);
+  if (!neighbor) return;
+  state.visited.add(neighborId);
+  if (shouldPruneNode(neighbor, pruneObservability, params)) {
+    state.pruned++;
+    return;
+  }
+  state.resultNodeMap.set(neighborId, neighbor);
+  addEdge(state, edge);
+  queue.push({ id: neighborId, depth: nextDepth });
+}
+function addCrossEdges(store, state) {
+  const resultNodeIds = new Set(state.resultNodeMap.keys());
+  for (const nodeId of resultNodeIds) {
+    const outEdges = store.getEdges({ from: nodeId });
+    for (const edge of outEdges) {
+      if (resultNodeIds.has(edge.to)) {
+        addEdge(state, edge);
+      }
+    }
+  }
+}
 var ContextQL = class {
   store;
   constructor(store) {
@@ -366,89 +413,69 @@ var ContextQL = class {
     const maxDepth = params.maxDepth ?? 3;
     const bidirectional = params.bidirectional ?? false;
     const pruneObservability = params.pruneObservability ?? true;
-    const visited = /* @__PURE__ */ new Set();
-    const resultNodeMap = /* @__PURE__ */ new Map();
-    const resultEdges = [];
-    const edgeSet = /* @__PURE__ */ new Set();
-    let pruned = 0;
-    let depthReached = 0;
-    const edgeKey = (e) => `${e.from}|${e.to}|${e.type}`;
-    const addEdge = (edge) => {
-      const key = edgeKey(edge);
-      if (!edgeSet.has(key)) {
-        edgeSet.add(key);
-        resultEdges.push(edge);
-      }
+    const state = {
+      visited: /* @__PURE__ */ new Set(),
+      resultNodeMap: /* @__PURE__ */ new Map(),
+      resultEdges: [],
+      edgeSet: /* @__PURE__ */ new Set(),
+      pruned: 0,
+      depthReached: 0
     };
     const queue = [];
-    for (const rootId of params.rootNodeIds) {
+    this.seedRootNodes(params.rootNodeIds, state, queue);
+    this.runBFS(queue, maxDepth, bidirectional, pruneObservability, params, state);
+    addCrossEdges(this.store, state);
+    return {
+      nodes: Array.from(state.resultNodeMap.values()),
+      edges: state.resultEdges,
+      stats: {
+        totalTraversed: state.visited.size,
+        totalReturned: state.resultNodeMap.size,
+        pruned: state.pruned,
+        depthReached: state.depthReached
+      }
+    };
+  }
+  seedRootNodes(rootNodeIds, state, queue) {
+    for (const rootId of rootNodeIds) {
       const node = this.store.getNode(rootId);
       if (node) {
-        visited.add(rootId);
-        resultNodeMap.set(rootId, node);
+        state.visited.add(rootId);
+        state.resultNodeMap.set(rootId, node);
         queue.push({ id: rootId, depth: 0 });
       }
     }
+  }
+  runBFS(queue, maxDepth, bidirectional, pruneObservability, params, state) {
     let head = 0;
     while (head < queue.length) {
       const entry = queue[head++];
       const { id: currentId, depth } = entry;
       if (depth >= maxDepth) continue;
       const nextDepth = depth + 1;
-      if (nextDepth > depthReached) depthReached = nextDepth;
-      const outEdges = this.store.getEdges({ from: currentId });
-      const inEdges = bidirectional ? this.store.getEdges({ to: currentId }) : [];
-      const allEdges = [
-        ...outEdges.map((e) => ({ edge: e, neighborId: e.to })),
-        ...inEdges.map((e) => ({ edge: e, neighborId: e.from }))
-      ];
+      if (nextDepth > state.depthReached) state.depthReached = nextDepth;
+      const allEdges = this.gatherEdges(currentId, bidirectional);
       for (const { edge, neighborId } of allEdges) {
-        if (params.includeEdges && !params.includeEdges.includes(edge.type)) {
-          continue;
-        }
-        if (visited.has(neighborId)) {
-          addEdge(edge);
-          continue;
-        }
-        const neighbor = this.store.getNode(neighborId);
-        if (!neighbor) continue;
-        visited.add(neighborId);
-        if (pruneObservability && OBSERVABILITY_TYPES.has(neighbor.type)) {
-          pruned++;
-          continue;
-        }
-        if (params.includeTypes && !params.includeTypes.includes(neighbor.type)) {
-          pruned++;
-          continue;
-        }
-        if (params.excludeTypes && params.excludeTypes.includes(neighbor.type)) {
-          pruned++;
-          continue;
-        }
-        resultNodeMap.set(neighborId, neighbor);
-        addEdge(edge);
-        queue.push({ id: neighborId, depth: nextDepth });
-      }
-    }
-    const resultNodeIds = new Set(resultNodeMap.keys());
-    for (const nodeId of resultNodeIds) {
-      const outEdges = this.store.getEdges({ from: nodeId });
-      for (const edge of outEdges) {
-        if (resultNodeIds.has(edge.to)) {
-          addEdge(edge);
-        }
+        processNeighbor(
+          this.store,
+          edge,
+          neighborId,
+          nextDepth,
+          queue,
+          state,
+          pruneObservability,
+          params
+        );
       }
     }
-    return {
-      nodes: Array.from(resultNodeMap.values()),
-      edges: resultEdges,
-      stats: {
-        totalTraversed: visited.size,
-        totalReturned: resultNodeMap.size,
-        pruned,
-        depthReached
-      }
-    };
+  }
+  gatherEdges(nodeId, bidirectional) {
+    const outEdges = this.store.getEdges({ from: nodeId });
+    const inEdges = bidirectional ? this.store.getEdges({ to: nodeId }) : [];
+    return [
+      ...outEdges.map((e) => ({ edge: e, neighborId: e.to })),
+      ...inEdges.map((e) => ({ edge: e, neighborId: e.from }))
+    ];
   }
 };
 
@@ -501,6 +528,15 @@ function groupNodesByImpact(nodes, excludeId) {
 // src/ingest/CodeIngestor.ts
 import * as fs from "fs/promises";
 import * as path from "path";
+var SKIP_METHOD_NAMES = /* @__PURE__ */ new Set(["constructor", "if", "for", "while", "switch"]);
+function countBraces(line) {
+  let net = 0;
+  for (const ch of line) {
+    if (ch === "{") net++;
+    else if (ch === "}") net--;
+  }
+  return net;
+}
 var CodeIngestor = class {
   constructor(store) {
     this.store = store;
@@ -515,41 +551,9 @@ var CodeIngestor = class {
     const fileContents = /* @__PURE__ */ new Map();
     for (const filePath of files) {
       try {
-        const relativePath = path.relative(rootDir, filePath).replace(/\\/g, "/");
-        const content = await fs.readFile(filePath, "utf-8");
-        const stat2 = await fs.stat(filePath);
-        const fileId = `file:${relativePath}`;
-        fileContents.set(relativePath, content);
-        const fileNode = {
-          id: fileId,
-          type: "file",
-          name: path.basename(filePath),
-          path: relativePath,
-          metadata: { language: this.detectLanguage(filePath) },
-          lastModified: stat2.mtime.toISOString()
-        };
-        this.store.addNode(fileNode);
-        nodesAdded++;
-        const symbols = this.extractSymbols(content, fileId, relativePath);
-        for (const { node, edge } of symbols) {
-          this.store.addNode(node);
-          this.store.addEdge(edge);
-          nodesAdded++;
-          edgesAdded++;
-          if (node.type === "function" || node.type === "method") {
-            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);
-        for (const edge of imports) {
-          this.store.addEdge(edge);
-          edgesAdded++;
-        }
+        const result = await this.processFile(filePath, rootDir, nameToFiles, fileContents);
+        nodesAdded += result.nodesAdded;
+        edgesAdded += result.edgesAdded;
       } catch (err) {
         errors.push(`${filePath}: ${err instanceof Error ? err.message : String(err)}`);
       }
@@ -568,6 +572,48 @@ var CodeIngestor = class {
       durationMs: Date.now() - start
     };
   }
+  async processFile(filePath, rootDir, nameToFiles, fileContents) {
+    let nodesAdded = 0;
+    let edgesAdded = 0;
+    const relativePath = path.relative(rootDir, filePath).replace(/\\/g, "/");
+    const content = await fs.readFile(filePath, "utf-8");
+    const stat2 = await fs.stat(filePath);
+    const fileId = `file:${relativePath}`;
+    fileContents.set(relativePath, content);
+    const fileNode = {
+      id: fileId,
+      type: "file",
+      name: path.basename(filePath),
+      path: relativePath,
+      metadata: { language: this.detectLanguage(filePath) },
+      lastModified: stat2.mtime.toISOString()
+    };
+    this.store.addNode(fileNode);
+    nodesAdded++;
+    const symbols = this.extractSymbols(content, fileId, relativePath);
+    for (const { node, edge } of symbols) {
+      this.store.addNode(node);
+      this.store.addEdge(edge);
+      nodesAdded++;
+      edgesAdded++;
+      this.trackCallable(node, relativePath, nameToFiles);
+    }
+    const imports = await this.extractImports(content, fileId, relativePath, rootDir);
+    for (const edge of imports) {
+      this.store.addEdge(edge);
+      edgesAdded++;
+    }
+    return { nodesAdded, edgesAdded };
+  }
+  trackCallable(node, relativePath, nameToFiles) {
+    if (node.type !== "function" && node.type !== "method") return;
+    let files = nameToFiles.get(node.name);
+    if (!files) {
+      files = /* @__PURE__ */ new Set();
+      nameToFiles.set(node.name, files);
+    }
+    files.add(relativePath);
+  }
   async findSourceFiles(dir) {
     const results = [];
     const entries = await fs.readdir(dir, { withFileTypes: true });
@@ -584,149 +630,152 @@ var CodeIngestor = class {
   extractSymbols(content, fileId, relativePath) {
     const results = [];
     const lines = content.split("\n");
-    let currentClassName = null;
-    let currentClassId = null;
-    let braceDepth = 0;
-    let insideClass = false;
+    const ctx = { className: null, classId: null, insideClass: false, braceDepth: 0 };
     for (let i = 0; i < lines.length; i++) {
       const line = lines[i];
-      const fnMatch = line.match(/(?:export\s+)?(?:async\s+)?function\s+(\w+)/);
-      if (fnMatch) {
-        const name = fnMatch[1];
-        const id = `function:${relativePath}:${name}`;
-        const endLine = this.findClosingBrace(lines, i);
-        results.push({
-          node: {
-            id,
-            type: "function",
-            name,
-            path: relativePath,
-            location: { fileId, startLine: i + 1, endLine },
-            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" }
-        });
-        if (!insideClass) {
-          currentClassName = null;
-          currentClassId = null;
-        }
-        continue;
-      }
-      const classMatch = line.match(/(?:export\s+)?class\s+(\w+)/);
-      if (classMatch) {
-        const name = classMatch[1];
-        const id = `class:${relativePath}:${name}`;
-        const endLine = this.findClosingBrace(lines, i);
-        results.push({
-          node: {
-            id,
-            type: "class",
-            name,
-            path: relativePath,
-            location: { fileId, startLine: i + 1, endLine },
-            metadata: { exported: line.includes("export") }
-          },
-          edge: { from: fileId, to: id, type: "contains" }
-        });
-        currentClassName = name;
-        currentClassId = id;
-        insideClass = true;
-        braceDepth = 0;
-        for (const ch of line) {
-          if (ch === "{") braceDepth++;
-          if (ch === "}") braceDepth--;
-        }
-        continue;
-      }
-      const ifaceMatch = line.match(/(?:export\s+)?interface\s+(\w+)/);
-      if (ifaceMatch) {
-        const name = ifaceMatch[1];
-        const id = `interface:${relativePath}:${name}`;
-        const endLine = this.findClosingBrace(lines, i);
-        results.push({
-          node: {
-            id,
-            type: "interface",
-            name,
-            path: relativePath,
-            location: { fileId, startLine: i + 1, endLine },
-            metadata: { exported: line.includes("export") }
-          },
-          edge: { from: fileId, to: id, type: "contains" }
-        });
-        currentClassName = null;
-        currentClassId = null;
-        insideClass = false;
-        continue;
-      }
-      if (insideClass) {
-        for (const ch of line) {
-          if (ch === "{") braceDepth++;
-          if (ch === "}") braceDepth--;
-        }
-        if (braceDepth <= 0) {
-          currentClassName = null;
-          currentClassId = null;
-          insideClass = false;
-          continue;
-        }
-      }
-      if (insideClass && currentClassName && currentClassId) {
-        const methodMatch = line.match(
-          /^\s+(?:(?:public|private|protected|readonly|static|abstract)\s+)*(?:async\s+)?(\w+)\s*\(/
-        );
-        if (methodMatch) {
-          const methodName = methodMatch[1];
-          if (methodName === "constructor" || methodName === "if" || methodName === "for" || methodName === "while" || methodName === "switch")
-            continue;
-          const id = `method:${relativePath}:${currentClassName}.${methodName}`;
-          const endLine = this.findClosingBrace(lines, i);
-          results.push({
-            node: {
-              id,
-              type: "method",
-              name: methodName,
-              path: relativePath,
-              location: { fileId, startLine: i + 1, endLine },
-              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" }
-          });
-        }
-        continue;
-      }
-      const varMatch = line.match(/(?:export\s+)?(?:const|let|var)\s+(\w+)/);
-      if (varMatch) {
-        const name = varMatch[1];
-        const id = `variable:${relativePath}:${name}`;
-        results.push({
-          node: {
-            id,
-            type: "variable",
-            name,
-            path: relativePath,
-            location: { fileId, startLine: i + 1, endLine: i + 1 },
-            metadata: { exported: line.includes("export") }
-          },
-          edge: { from: fileId, to: id, type: "contains" }
-        });
-      }
+      if (this.tryExtractFunction(line, lines, i, fileId, relativePath, ctx, results)) continue;
+      if (this.tryExtractClass(line, lines, i, fileId, relativePath, ctx, results)) continue;
+      if (this.tryExtractInterface(line, lines, i, fileId, relativePath, ctx, results)) continue;
+      if (this.updateClassContext(line, ctx)) continue;
+      if (this.tryExtractMethod(line, lines, i, fileId, relativePath, ctx, results)) continue;
+      if (ctx.insideClass) continue;
+      this.tryExtractVariable(line, i, fileId, relativePath, results);
     }
     return results;
   }
+  tryExtractFunction(line, lines, i, fileId, relativePath, ctx, results) {
+    const fnMatch = line.match(/(?:export\s+)?(?:async\s+)?function\s+(\w+)/);
+    if (!fnMatch) return false;
+    const name = fnMatch[1];
+    const id = `function:${relativePath}:${name}`;
+    const endLine = this.findClosingBrace(lines, i);
+    results.push({
+      node: {
+        id,
+        type: "function",
+        name,
+        path: relativePath,
+        location: { fileId, startLine: i + 1, endLine },
+        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" }
+    });
+    if (!ctx.insideClass) {
+      ctx.className = null;
+      ctx.classId = null;
+    }
+    return true;
+  }
+  tryExtractClass(line, lines, i, fileId, relativePath, ctx, results) {
+    const classMatch = line.match(/(?:export\s+)?class\s+(\w+)/);
+    if (!classMatch) return false;
+    const name = classMatch[1];
+    const id = `class:${relativePath}:${name}`;
+    const endLine = this.findClosingBrace(lines, i);
+    results.push({
+      node: {
+        id,
+        type: "class",
+        name,
+        path: relativePath,
+        location: { fileId, startLine: i + 1, endLine },
+        metadata: { exported: line.includes("export") }
+      },
+      edge: { from: fileId, to: id, type: "contains" }
+    });
+    ctx.className = name;
+    ctx.classId = id;
+    ctx.insideClass = true;
+    ctx.braceDepth = countBraces(line);
+    return true;
+  }
+  tryExtractInterface(line, lines, i, fileId, relativePath, ctx, results) {
+    const ifaceMatch = line.match(/(?:export\s+)?interface\s+(\w+)/);
+    if (!ifaceMatch) return false;
+    const name = ifaceMatch[1];
+    const id = `interface:${relativePath}:${name}`;
+    const endLine = this.findClosingBrace(lines, i);
+    results.push({
+      node: {
+        id,
+        type: "interface",
+        name,
+        path: relativePath,
+        location: { fileId, startLine: i + 1, endLine },
+        metadata: { exported: line.includes("export") }
+      },
+      edge: { from: fileId, to: id, type: "contains" }
+    });
+    ctx.className = null;
+    ctx.classId = null;
+    ctx.insideClass = false;
+    return true;
+  }
+  /** Update brace tracking; returns true when line is consumed (class ended or tracked). */
+  updateClassContext(line, ctx) {
+    if (!ctx.insideClass) return false;
+    ctx.braceDepth += countBraces(line);
+    if (ctx.braceDepth <= 0) {
+      ctx.className = null;
+      ctx.classId = null;
+      ctx.insideClass = false;
+      return true;
+    }
+    return false;
+  }
+  tryExtractMethod(line, lines, i, fileId, relativePath, ctx, results) {
+    if (!ctx.insideClass || !ctx.className || !ctx.classId) return false;
+    const methodMatch = line.match(
+      /^\s+(?:(?:public|private|protected|readonly|static|abstract)\s+)*(?:async\s+)?(\w+)\s*\(/
+    );
+    if (!methodMatch) return false;
+    const methodName = methodMatch[1];
+    if (SKIP_METHOD_NAMES.has(methodName)) return false;
+    const id = `method:${relativePath}:${ctx.className}.${methodName}`;
+    const endLine = this.findClosingBrace(lines, i);
+    results.push({
+      node: {
+        id,
+        type: "method",
+        name: methodName,
+        path: relativePath,
+        location: { fileId, startLine: i + 1, endLine },
+        metadata: {
+          className: ctx.className,
+          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: ctx.classId, to: id, type: "contains" }
+    });
+    return true;
+  }
+  tryExtractVariable(line, i, fileId, relativePath, results) {
+    const varMatch = line.match(/(?:export\s+)?(?:const|let|var)\s+(\w+)/);
+    if (!varMatch) return;
+    const name = varMatch[1];
+    const id = `variable:${relativePath}:${name}`;
+    results.push({
+      node: {
+        id,
+        type: "variable",
+        name,
+        path: relativePath,
+        location: { fileId, startLine: i + 1, endLine: i + 1 },
+        metadata: { exported: line.includes("export") }
+      },
+      edge: { from: fileId, to: id, type: "contains" }
+    });
+  }
   /**
    * Find the closing brace for a construct starting at the given line.
    * Uses a simple brace-counting heuristic. Returns 1-indexed line number.
@@ -1346,17 +1395,33 @@ var KnowledgeIngestor = class {
 
 // src/ingest/connectors/ConnectorUtils.ts
 var CODE_NODE_TYPES2 = ["file", "function", "class", "method", "interface", "variable"];
+var SANITIZE_RULES = [
+  // Strip XML/HTML-like instruction tags that could be interpreted as system prompts
+  {
+    pattern: /<\/?(?:system|instruction|prompt|role|context|tool_call|function_call|assistant|human|user)[^>]*>/gi,
+    replacement: ""
+  },
+  // Strip markdown-style system prompt markers (including trailing space)
+  {
+    pattern: /^#{1,3}\s*(?:system|instruction|prompt)\s*[:：]\s*/gim,
+    replacement: ""
+  },
+  // Strip common injection prefixes
+  {
+    pattern: /(?:ignore|disregard|forget)\s+(?:all\s+)?(?:previous|prior|above)\s+(?:instructions?|prompts?|context)/gi,
+    replacement: "[filtered]"
+  },
+  // Strip "you are now" re-roling attempts (only when followed by AI/agent role words)
+  {
+    pattern: /you\s+are\s+now\s+(?:a\s+)?(?:helpful\s+)?(?:an?\s+)?(?:assistant|system|ai|bot|agent|tool)\b/gi,
+    replacement: "[filtered]"
+  }
+];
 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]"
-  );
+  let sanitized = text;
+  for (const rule of SANITIZE_RULES) {
+    sanitized = sanitized.replace(rule.pattern, rule.replacement);
+  }
   if (sanitized.length > maxLength) {
     sanitized = sanitized.slice(0, maxLength) + "\u2026";
   }
@@ -1456,6 +1521,28 @@ var SyncManager = class {
 };
 
 // src/ingest/connectors/JiraConnector.ts
+function buildIngestResult(nodesAdded, edgesAdded, errors, start) {
+  return {
+    nodesAdded,
+    nodesUpdated: 0,
+    edgesAdded,
+    edgesUpdated: 0,
+    errors,
+    durationMs: Date.now() - start
+  };
+}
+function buildJql(config) {
+  const project2 = config.project;
+  let jql = project2 ? `project=${project2}` : "";
+  const filters = config.filters;
+  if (filters?.status?.length) {
+    jql += `${jql ? " AND " : ""}status IN (${filters.status.map((s) => `"${s}"`).join(",")})`;
+  }
+  if (filters?.labels?.length) {
+    jql += `${jql ? " AND " : ""}labels IN (${filters.labels.map((l) => `"${l}"`).join(",")})`;
+  }
+  return jql;
+}
 var JiraConnector = class {
   name = "jira";
   source = "jira";
@@ -1465,105 +1552,81 @@ var JiraConnector = class {
   }
   async ingest(store, config) {
     const start = Date.now();
-    const errors = [];
     let nodesAdded = 0;
     let edgesAdded = 0;
     const apiKeyEnv = config.apiKeyEnv ?? "JIRA_API_KEY";
     const apiKey = process.env[apiKeyEnv];
     if (!apiKey) {
-      return {
-        nodesAdded: 0,
-        nodesUpdated: 0,
-        edgesAdded: 0,
-        edgesUpdated: 0,
-        errors: [`Missing API key: environment variable "${apiKeyEnv}" is not set`],
-        durationMs: Date.now() - start
-      };
+      return buildIngestResult(
+        0,
+        0,
+        [`Missing API key: environment variable "${apiKeyEnv}" is not set`],
+        start
+      );
     }
     const baseUrlEnv = config.baseUrlEnv ?? "JIRA_BASE_URL";
     const baseUrl = process.env[baseUrlEnv];
     if (!baseUrl) {
-      return {
-        nodesAdded: 0,
-        nodesUpdated: 0,
-        edgesAdded: 0,
-        edgesUpdated: 0,
-        errors: [`Missing base URL: environment variable "${baseUrlEnv}" is not set`],
-        durationMs: Date.now() - start
-      };
-    }
-    const project2 = config.project;
-    let jql = project2 ? `project=${project2}` : "";
-    const filters = config.filters;
-    if (filters?.status?.length) {
-      jql += `${jql ? " AND " : ""}status IN (${filters.status.map((s) => `"${s}"`).join(",")})`;
-    }
-    if (filters?.labels?.length) {
-      jql += `${jql ? " AND " : ""}labels IN (${filters.labels.map((l) => `"${l}"`).join(",")})`;
+      return buildIngestResult(
+        0,
+        0,
+        [`Missing base URL: environment variable "${baseUrlEnv}" is not set`],
+        start
+      );
     }
+    const jql = buildJql(config);
     const headers = {
       Authorization: `Basic ${apiKey}`,
       "Content-Type": "application/json"
     };
-    let startAt = 0;
-    const maxResults = 50;
-    let total = Infinity;
     try {
+      let startAt = 0;
+      const maxResults = 50;
+      let total = Infinity;
       while (startAt < total) {
         const url = `${baseUrl}/rest/api/2/search?jql=${encodeURIComponent(jql)}&startAt=${startAt}&maxResults=${maxResults}`;
         const response = await this.httpClient(url, { headers });
         if (!response.ok) {
-          return {
-            nodesAdded,
-            nodesUpdated: 0,
-            edgesAdded,
-            edgesUpdated: 0,
-            errors: ["Jira API request failed"],
-            durationMs: Date.now() - start
-          };
+          return buildIngestResult(nodesAdded, edgesAdded, ["Jira API request failed"], start);
         }
         const data = await response.json();
         total = data.total;
         for (const issue of data.issues) {
-          const nodeId = `issue:jira:${issue.key}`;
-          store.addNode({
-            id: nodeId,
-            type: "issue",
-            name: sanitizeExternalText(issue.fields.summary, 500),
-            metadata: {
-              key: issue.key,
-              status: issue.fields.status?.name,
-              priority: issue.fields.priority?.name,
-              assignee: issue.fields.assignee?.displayName,
-              labels: issue.fields.labels ?? []
-            }
-          });
-          nodesAdded++;
-          const searchText = sanitizeExternalText(
-            [issue.fields.summary, issue.fields.description ?? ""].join(" ")
-          );
-          edgesAdded += linkToCode(store, searchText, nodeId, "applies_to");
+          const counts = this.processIssue(store, issue);
+          nodesAdded += counts.nodesAdded;
+          edgesAdded += counts.edgesAdded;
         }
         startAt += maxResults;
       }
     } catch (err) {
-      return {
+      return buildIngestResult(
         nodesAdded,
-        nodesUpdated: 0,
         edgesAdded,
-        edgesUpdated: 0,
-        errors: [`Jira API error: ${err instanceof Error ? err.message : String(err)}`],
-        durationMs: Date.now() - start
-      };
+        [`Jira API error: ${err instanceof Error ? err.message : String(err)}`],
+        start
+      );
     }
-    return {
-      nodesAdded,
-      nodesUpdated: 0,
-      edgesAdded,
-      edgesUpdated: 0,
-      errors,
-      durationMs: Date.now() - start
-    };
+    return buildIngestResult(nodesAdded, edgesAdded, [], start);
+  }
+  processIssue(store, issue) {
+    const nodeId = `issue:jira:${issue.key}`;
+    store.addNode({
+      id: nodeId,
+      type: "issue",
+      name: sanitizeExternalText(issue.fields.summary, 500),
+      metadata: {
+        key: issue.key,
+        status: issue.fields.status?.name,
+        priority: issue.fields.priority?.name,
+        assignee: issue.fields.assignee?.displayName,
+        labels: issue.fields.labels ?? []
+      }
+    });
+    const searchText = sanitizeExternalText(
+      [issue.fields.summary, issue.fields.description ?? ""].join(" ")
+    );
+    const edgesAdded = linkToCode(store, searchText, nodeId, "applies_to");
+    return { nodesAdded: 1, edgesAdded };
   }
 };
 
@@ -1596,44 +1659,10 @@ var SlackConnector = class {
     const oldest = config.lookbackDays ? String(Math.floor((Date.now() - Number(config.lookbackDays) * 864e5) / 1e3)) : void 0;
     for (const channel of channels) {
       try {
-        let url = `https://slack.com/api/conversations.history?channel=${encodeURIComponent(channel)}`;
-        if (oldest) {
-          url += `&oldest=${oldest}`;
-        }
-        const response = await this.httpClient(url, {
-          headers: {
-            Authorization: `Bearer ${apiKey}`,
-            "Content-Type": "application/json"
-          }
-        });
-        if (!response.ok) {
-          errors.push(`Slack API request failed for channel ${channel}`);
-          continue;
-        }
-        const data = await response.json();
-        if (!data.ok) {
-          errors.push(`Slack API error for channel ${channel}`);
-          continue;
-        }
-        for (const message of data.messages) {
-          const nodeId = `conversation:slack:${channel}:${message.ts}`;
-          const sanitizedText = sanitizeExternalText(message.text);
-          const snippet = sanitizedText.length > 100 ? sanitizedText.slice(0, 100) : sanitizedText;
-          store.addNode({
-            id: nodeId,
-            type: "conversation",
-            name: snippet,
-            metadata: {
-              author: message.user,
-              channel,
-              timestamp: message.ts
-            }
-          });
-          nodesAdded++;
-          edgesAdded += linkToCode(store, sanitizedText, nodeId, "references", {
-            checkPaths: true
-          });
-        }
+        const result = await this.processChannel(store, channel, apiKey, oldest);
+        nodesAdded += result.nodesAdded;
+        edgesAdded += result.edgesAdded;
+        errors.push(...result.errors);
       } catch (err) {
         errors.push(
           `Slack API error for channel ${channel}: ${err instanceof Error ? err.message : String(err)}`
@@ -1649,6 +1678,52 @@ var SlackConnector = class {
       durationMs: Date.now() - start
     };
   }
+  async processChannel(store, channel, apiKey, oldest) {
+    const errors = [];
+    let nodesAdded = 0;
+    let edgesAdded = 0;
+    let url = `https://slack.com/api/conversations.history?channel=${encodeURIComponent(channel)}`;
+    if (oldest) {
+      url += `&oldest=${oldest}`;
+    }
+    const response = await this.httpClient(url, {
+      headers: {
+        Authorization: `Bearer ${apiKey}`,
+        "Content-Type": "application/json"
+      }
+    });
+    if (!response.ok) {
+      return {
+        nodesAdded: 0,
+        edgesAdded: 0,
+        errors: [`Slack API request failed for channel ${channel}`]
+      };
+    }
+    const data = await response.json();
+    if (!data.ok) {
+      return { nodesAdded: 0, edgesAdded: 0, errors: [`Slack API error for channel ${channel}`] };
+    }
+    for (const message of data.messages) {
+      const nodeId = `conversation:slack:${channel}:${message.ts}`;
+      const sanitizedText = sanitizeExternalText(message.text);
+      const snippet = sanitizedText.length > 100 ? sanitizedText.slice(0, 100) : sanitizedText;
+      store.addNode({
+        id: nodeId,
+        type: "conversation",
+        name: snippet,
+        metadata: {
+          author: message.user,
+          channel,
+          timestamp: message.ts
+        }
+      });
+      nodesAdded++;
+      edgesAdded += linkToCode(store, sanitizedText, nodeId, "references", {
+        checkPaths: true
+      });
+    }
+    return { nodesAdded, edgesAdded, errors };
+  }
 };
 
 // src/ingest/connectors/ConfluenceConnector.ts
@@ -1680,36 +1755,10 @@ var ConfluenceConnector = class {
     const baseUrl = process.env[baseUrlEnv] ?? "";
     const spaceKey = config.spaceKey ?? "";
     try {
-      let nextUrl = `${baseUrl}/wiki/api/v2/pages?spaceKey=${encodeURIComponent(spaceKey)}&limit=25&body-format=storage`;
-      while (nextUrl) {
-        const response = await this.httpClient(nextUrl, {
-          headers: { Authorization: `Bearer ${apiKey}` }
-        });
-        if (!response.ok) {
-          errors.push(`Confluence API error: status ${response.status}`);
-          break;
-        }
-        const data = await response.json();
-        for (const page of data.results) {
-          const nodeId = `confluence:${page.id}`;
-          store.addNode({
-            id: nodeId,
-            type: "document",
-            name: sanitizeExternalText(page.title, 500),
-            metadata: {
-              source: "confluence",
-              spaceKey,
-              pageId: page.id,
-              status: page.status,
-              url: page._links?.webui ?? ""
-            }
-          });
-          nodesAdded++;
-          const text = sanitizeExternalText(`${page.title} ${page.body?.storage?.value ?? ""}`);
-          edgesAdded += linkToCode(store, text, nodeId, "documents");
-        }
-        nextUrl = data._links?.next ? `${baseUrl}${data._links.next}` : null;
-      }
+      const result = await this.fetchAllPages(store, baseUrl, apiKey, spaceKey);
+      nodesAdded = result.nodesAdded;
+      edgesAdded = result.edgesAdded;
+      errors.push(...result.errors);
     } catch (err) {
       errors.push(`Confluence fetch error: ${err instanceof Error ? err.message : String(err)}`);
     }
@@ -1722,6 +1771,47 @@ var ConfluenceConnector = class {
       durationMs: Date.now() - start
     };
   }
+  async fetchAllPages(store, baseUrl, apiKey, spaceKey) {
+    const errors = [];
+    let nodesAdded = 0;
+    let edgesAdded = 0;
+    let nextUrl = `${baseUrl}/wiki/api/v2/pages?spaceKey=${encodeURIComponent(spaceKey)}&limit=25&body-format=storage`;
+    while (nextUrl) {
+      const response = await this.httpClient(nextUrl, {
+        headers: { Authorization: `Bearer ${apiKey}` }
+      });
+      if (!response.ok) {
+        errors.push(`Confluence API error: status ${response.status}`);
+        break;
+      }
+      const data = await response.json();
+      for (const page of data.results) {
+        const counts = this.processPage(store, page, spaceKey);
+        nodesAdded += counts.nodesAdded;
+        edgesAdded += counts.edgesAdded;
+      }
+      nextUrl = data._links?.next ? `${baseUrl}${data._links.next}` : null;
+    }
+    return { nodesAdded, edgesAdded, errors };
+  }
+  processPage(store, page, spaceKey) {
+    const nodeId = `confluence:${page.id}`;
+    store.addNode({
+      id: nodeId,
+      type: "document",
+      name: sanitizeExternalText(page.title, 500),
+      metadata: {
+        source: "confluence",
+        spaceKey,
+        pageId: page.id,
+        status: page.status,
+        url: page._links?.webui ?? ""
+      }
+    });
+    const text = sanitizeExternalText(`${page.title} ${page.body?.storage?.value ?? ""}`);
+    const edgesAdded = linkToCode(store, text, nodeId, "documents");
+    return { nodesAdded: 1, edgesAdded };
+  }
 };
 
 // src/ingest/connectors/CIConnector.ts
@@ -2014,22 +2104,25 @@ var GraphEntropyAdapter = class {
    * 3. Unreachable = code nodes NOT in visited set
    */
   computeDeadCodeData() {
-    const allFileNodes = this.store.findNodes({ type: "file" });
+    const entryPoints = this.findEntryPoints();
+    const visited = this.bfsFromEntryPoints(entryPoints);
+    const unreachableNodes = this.collectUnreachableNodes(visited);
+    return { reachableNodeIds: visited, unreachableNodes, entryPoints };
+  }
+  findEntryPoints() {
     const entryPoints = [];
-    for (const node of allFileNodes) {
-      if (node.name === "index.ts" || node.metadata?.entryPoint === true) {
-        entryPoints.push(node.id);
-      }
-    }
     for (const nodeType of CODE_NODE_TYPES3) {
-      if (nodeType === "file") continue;
       const nodes = this.store.findNodes({ type: nodeType });
       for (const node of nodes) {
-        if (node.metadata?.entryPoint === true) {
+        const isIndexFile = nodeType === "file" && node.name === "index.ts";
+        if (isIndexFile || node.metadata?.entryPoint === true) {
           entryPoints.push(node.id);
         }
       }
     }
+    return entryPoints;
+  }
+  bfsFromEntryPoints(entryPoints) {
     const visited = /* @__PURE__ */ new Set();
     const queue = [...entryPoints];
     let head = 0;
@@ -2037,25 +2130,22 @@ var GraphEntropyAdapter = class {
       const nodeId = queue[head++];
       if (visited.has(nodeId)) continue;
       visited.add(nodeId);
-      const importEdges = this.store.getEdges({ from: nodeId, type: "imports" });
-      for (const edge of importEdges) {
-        if (!visited.has(edge.to)) {
-          queue.push(edge.to);
-        }
-      }
-      const callEdges = this.store.getEdges({ from: nodeId, type: "calls" });
-      for (const edge of callEdges) {
-        if (!visited.has(edge.to)) {
-          queue.push(edge.to);
-        }
-      }
-      const containsEdges = this.store.getEdges({ from: nodeId, type: "contains" });
-      for (const edge of containsEdges) {
+      this.enqueueOutboundEdges(nodeId, visited, queue);
+    }
+    return visited;
+  }
+  enqueueOutboundEdges(nodeId, visited, queue) {
+    const edgeTypes = ["imports", "calls", "contains"];
+    for (const edgeType of edgeTypes) {
+      const edges = this.store.getEdges({ from: nodeId, type: edgeType });
+      for (const edge of edges) {
         if (!visited.has(edge.to)) {
           queue.push(edge.to);
         }
       }
     }
+  }
+  collectUnreachableNodes(visited) {
     const unreachableNodes = [];
     for (const nodeType of CODE_NODE_TYPES3) {
       const nodes = this.store.findNodes({ type: nodeType });
@@ -2070,11 +2160,7 @@ var GraphEntropyAdapter = class {
         }
       }
     }
-    return {
-      reachableNodeIds: visited,
-      unreachableNodes,
-      entryPoints
-    };
+    return unreachableNodes;
   }
   /**
    * Count all nodes and edges by type.
@@ -2125,33 +2211,9 @@ var GraphComplexityAdapter = class {
     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;
-        }
-      }
+      const fileId = this.findContainingFileId(fnNode.id);
       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 changeFrequency = this.getChangeFrequency(fileId, fileChangeFrequency);
       const hotspotScore = changeFrequency * complexity;
       const filePath = fnNode.path ?? fileId.replace(/^file:/, "");
       hotspots.push({
@@ -2169,6 +2231,39 @@ var GraphComplexityAdapter = class {
     );
     return { hotspots, percentile95Score };
   }
+  /**
+   * Walk the 'contains' edges to find the file node that contains a given function/method.
+   * For methods, walks through the intermediate class node.
+   */
+  findContainingFileId(nodeId) {
+    const containsEdges = this.store.getEdges({ to: nodeId, type: "contains" });
+    for (const edge of containsEdges) {
+      const sourceNode = this.store.getNode(edge.from);
+      if (sourceNode?.type === "file") return sourceNode.id;
+      if (sourceNode?.type === "class") {
+        const fileId = this.findParentFileOfClass(sourceNode.id);
+        if (fileId) return fileId;
+      }
+    }
+    return void 0;
+  }
+  findParentFileOfClass(classNodeId) {
+    const classContainsEdges = this.store.getEdges({ to: classNodeId, type: "contains" });
+    for (const classEdge of classContainsEdges) {
+      const parentNode = this.store.getNode(classEdge.from);
+      if (parentNode?.type === "file") return parentNode.id;
+    }
+    return void 0;
+  }
+  getChangeFrequency(fileId, cache) {
+    let freq = cache.get(fileId);
+    if (freq === void 0) {
+      const referencesEdges = this.store.getEdges({ to: fileId, type: "references" });
+      freq = referencesEdges.length;
+      cache.set(fileId, freq);
+    }
+    return freq;
+  }
   computePercentile(descendingScores, percentile) {
     if (descendingScores.length === 0) return 0;
     const ascending = [...descendingScores].sort((a, b) => a - b);
@@ -2816,6 +2911,23 @@ var STOP_WORDS2 = /* @__PURE__ */ new Set([
 var PASCAL_OR_CAMEL_RE = /\b([A-Z][a-z]+[A-Za-z]*[a-z][A-Za-z]*|[a-z]+[A-Z][A-Za-z]*)\b/g;
 var FILE_PATH_RE = /(?:\.\/|[a-zA-Z0-9_-]+\/)[a-zA-Z0-9_\-./]+\.[a-zA-Z]{1,10}/g;
 var QUOTED_RE = /["']([^"']+)["']/g;
+function isSkippableWord(cleaned, allConsumed) {
+  if (allConsumed.has(cleaned)) return true;
+  const lower = cleaned.toLowerCase();
+  if (STOP_WORDS2.has(lower)) return true;
+  if (INTENT_KEYWORDS.has(lower)) return true;
+  if (cleaned === cleaned.toUpperCase() && /^[A-Z]+$/.test(cleaned)) return true;
+  return false;
+}
+function buildConsumedSet(quotedConsumed, casingConsumed, pathConsumed) {
+  const quotedWords = /* @__PURE__ */ new Set();
+  for (const q of quotedConsumed) {
+    for (const w of q.split(/\s+/)) {
+      if (w.length > 0) quotedWords.add(w);
+    }
+  }
+  return /* @__PURE__ */ new Set([...quotedConsumed, ...quotedWords, ...casingConsumed, ...pathConsumed]);
+}
 var EntityExtractor = class {
   /**
    * Extract candidate entity mentions from a natural language query.
@@ -2856,27 +2968,12 @@ var EntityExtractor = class {
       add(path6);
       pathConsumed.add(path6);
     }
-    const quotedWords = /* @__PURE__ */ new Set();
-    for (const q of quotedConsumed) {
-      for (const w of q.split(/\s+/)) {
-        if (w.length > 0) quotedWords.add(w);
-      }
-    }
-    const allConsumed = /* @__PURE__ */ new Set([
-      ...quotedConsumed,
-      ...quotedWords,
-      ...casingConsumed,
-      ...pathConsumed
-    ]);
+    const allConsumed = buildConsumedSet(quotedConsumed, casingConsumed, pathConsumed);
     const words = trimmed.split(/\s+/);
     for (const raw of words) {
       const cleaned = raw.replace(/^[^a-zA-Z0-9]+|[^a-zA-Z0-9]+$/g, "");
       if (cleaned.length === 0) continue;
-      const lower = cleaned.toLowerCase();
-      if (allConsumed.has(cleaned)) continue;
-      if (STOP_WORDS2.has(lower)) continue;
-      if (INTENT_KEYWORDS.has(lower)) continue;
-      if (cleaned === cleaned.toUpperCase() && /^[A-Z]+$/.test(cleaned)) continue;
+      if (isSkippableWord(cleaned, allConsumed)) continue;
       add(cleaned);
     }
     return result;
@@ -3199,14 +3296,20 @@ var Assembler = class {
     const fusion = this.getFusionLayer();
     const topResults = fusion.search(intent, 10);
     if (topResults.length === 0) {
-      return {
-        nodes: [],
-        edges: [],
-        tokenEstimate: 0,
-        intent,
-        truncated: false
-      };
+      return { nodes: [], edges: [], tokenEstimate: 0, intent, truncated: false };
     }
+    const { nodeMap, collectedEdges, nodeScores } = this.expandSearchResults(topResults);
+    const sortedNodes = Array.from(nodeMap.values()).sort((a, b) => {
+      return (nodeScores.get(b.id) ?? 0) - (nodeScores.get(a.id) ?? 0);
+    });
+    const { keptNodes, tokenEstimate, truncated } = this.truncateToFit(sortedNodes, tokenBudget);
+    const keptNodeIds = new Set(keptNodes.map((n) => n.id));
+    const keptEdges = collectedEdges.filter(
+      (e) => keptNodeIds.has(e.from) && keptNodeIds.has(e.to)
+    );
+    return { nodes: keptNodes, edges: keptEdges, tokenEstimate, intent, truncated };
+  }
+  expandSearchResults(topResults) {
     const contextQL = new ContextQL(this.store);
     const nodeMap = /* @__PURE__ */ new Map();
     const edgeSet = /* @__PURE__ */ new Set();
@@ -3234,9 +3337,9 @@ var Assembler = class {
         }
       }
     }
-    const sortedNodes = Array.from(nodeMap.values()).sort((a, b) => {
-      return (nodeScores.get(b.id) ?? 0) - (nodeScores.get(a.id) ?? 0);
-    });
+    return { nodeMap, collectedEdges, nodeScores };
+  }
+  truncateToFit(sortedNodes, tokenBudget) {
     let tokenEstimate = 0;
     const keptNodes = [];
     let truncated = false;
@@ -3249,17 +3352,7 @@ var Assembler = class {
       tokenEstimate += nodeTokens;
       keptNodes.push(node);
     }
-    const keptNodeIds = new Set(keptNodes.map((n) => n.id));
-    const keptEdges = collectedEdges.filter(
-      (e) => keptNodeIds.has(e.from) && keptNodeIds.has(e.to)
-    );
-    return {
-      nodes: keptNodes,
-      edges: keptEdges,
-      tokenEstimate,
-      intent,
-      truncated
-    };
+    return { keptNodes, tokenEstimate, truncated };
   }
   /**
    * Compute a token budget allocation across node types.
@@ -3432,8 +3525,8 @@ var GraphConstraintAdapter = class {
     const { edges } = this.computeDependencyGraph();
     const violations = [];
     for (const edge of edges) {
-      const fromRelative = relative2(rootDir, edge.from);
-      const toRelative = relative2(rootDir, edge.to);
+      const fromRelative = relative2(rootDir, edge.from).replaceAll("\\", "/");
+      const toRelative = relative2(rootDir, edge.to).replaceAll("\\", "/");
       const fromLayer = this.resolveLayer(fromRelative, layers);
       const toLayer = this.resolveLayer(toRelative, layers);
       if (!fromLayer || !toLayer) continue;