@harness-engineering/graph 0.3.1 → 0.3.2

package/dist/index.js

@@ -34,11 +34,14 @@ __export(index_exports, {
   CIConnector: () => CIConnector,
   CURRENT_SCHEMA_VERSION: () => CURRENT_SCHEMA_VERSION,
   CodeIngestor: () => CodeIngestor,
+  ConflictPredictor: () => ConflictPredictor,
   ConfluenceConnector: () => ConfluenceConnector,
   ContextQL: () => ContextQL,
   DesignConstraintAdapter: () => DesignConstraintAdapter,
   DesignIngestor: () => DesignIngestor,
   EDGE_TYPES: () => EDGE_TYPES,
+  EntityExtractor: () => EntityExtractor,
+  EntityResolver: () => EntityResolver,
   FusionLayer: () => FusionLayer,
   GitIngestor: () => GitIngestor,
   GraphAnomalyAdapter: () => GraphAnomalyAdapter,
@@ -50,15 +53,21 @@ __export(index_exports, {
   GraphFeedbackAdapter: () => GraphFeedbackAdapter,
   GraphNodeSchema: () => GraphNodeSchema,
   GraphStore: () => GraphStore,
+  INTENTS: () => INTENTS,
+  IntentClassifier: () => IntentClassifier,
   JiraConnector: () => JiraConnector,
   KnowledgeIngestor: () => KnowledgeIngestor,
   NODE_TYPES: () => NODE_TYPES,
   OBSERVABILITY_TYPES: () => OBSERVABILITY_TYPES,
+  ResponseFormatter: () => ResponseFormatter,
   SlackConnector: () => SlackConnector,
   SyncManager: () => SyncManager,
+  TaskIndependenceAnalyzer: () => TaskIndependenceAnalyzer,
   TopologicalLinker: () => TopologicalLinker,
   VERSION: () => VERSION,
   VectorStore: () => VectorStore,
+  askGraph: () => askGraph,
+  groupNodesByImpact: () => groupNodesByImpact,
   linkToCode: () => linkToCode,
   loadGraph: () => loadGraph,
   project: () => project,
@@ -534,6 +543,38 @@ function project(nodes, spec) {
   });
 }
 
+// src/query/groupImpact.ts
+var TEST_TYPES = /* @__PURE__ */ new Set(["test_result"]);
+var DOC_TYPES = /* @__PURE__ */ new Set(["adr", "decision", "document", "learning"]);
+var CODE_TYPES = /* @__PURE__ */ new Set([
+  "file",
+  "module",
+  "class",
+  "interface",
+  "function",
+  "method",
+  "variable"
+]);
+function groupNodesByImpact(nodes, excludeId) {
+  const tests = [];
+  const docs = [];
+  const code = [];
+  const other = [];
+  for (const node of nodes) {
+    if (excludeId && node.id === excludeId) continue;
+    if (TEST_TYPES.has(node.type)) {
+      tests.push(node);
+    } else if (DOC_TYPES.has(node.type)) {
+      docs.push(node);
+    } else if (CODE_TYPES.has(node.type)) {
+      code.push(node);
+    } else {
+      other.push(node);
+    }
+  }
+  return { tests, docs, code, other };
+}
+
 // src/ingest/CodeIngestor.ts
 var fs = __toESM(require("fs/promises"));
 var path = __toESM(require("path"));
@@ -2511,6 +2552,687 @@ var GraphAnomalyAdapter = class {
   }
 };
 
+// src/nlq/types.ts
+var INTENTS = ["impact", "find", "relationships", "explain", "anomaly"];
+
+// src/nlq/IntentClassifier.ts
+var SIGNAL_WEIGHTS = {
+  keyword: 0.35,
+  questionWord: 0.2,
+  verbPattern: 0.45
+};
+var INTENT_SIGNALS = {
+  impact: {
+    keywords: [
+      "break",
+      "affect",
+      "impact",
+      "change",
+      "depend",
+      "blast",
+      "radius",
+      "risk",
+      "delete",
+      "remove"
+    ],
+    questionWords: ["what", "if"],
+    verbPatterns: [
+      /what\s+(breaks|happens|is affected)/,
+      /if\s+i\s+(change|modify|remove|delete)/,
+      /blast\s+radius/,
+      /what\s+(depend|relies)/
+    ]
+  },
+  find: {
+    keywords: ["find", "where", "locate", "search", "list", "all", "every"],
+    questionWords: ["where"],
+    verbPatterns: [
+      /where\s+is/,
+      /find\s+(the|all|every)/,
+      /show\s+me/,
+      /show\s+(all|every|the)/,
+      /locate\s+/,
+      /list\s+(all|every|the)/
+    ]
+  },
+  relationships: {
+    keywords: [
+      "connect",
+      "call",
+      "import",
+      "use",
+      "depend",
+      "link",
+      "neighbor",
+      "caller",
+      "callee"
+    ],
+    questionWords: ["what", "who"],
+    verbPatterns: [/connects?\s+to/, /depends?\s+on/, /\bcalls?\b/, /\bimports?\b/]
+  },
+  explain: {
+    keywords: ["describe", "explain", "tell", "about", "overview", "summary", "work"],
+    questionWords: ["what", "how"],
+    verbPatterns: [
+      /what\s+is\s+\w/,
+      /describe\s+/,
+      /tell\s+me\s+about/,
+      /how\s+does/,
+      /overview\s+of/,
+      /give\s+me\s+/
+    ]
+  },
+  anomaly: {
+    keywords: [
+      "wrong",
+      "problem",
+      "anomaly",
+      "smell",
+      "issue",
+      "outlier",
+      "hotspot",
+      "suspicious",
+      "risk"
+    ],
+    questionWords: ["what"],
+    verbPatterns: [
+      /what.*(wrong|problem|smell)/,
+      /find.*(issue|anomal|problem)/,
+      /code\s+smell/,
+      /suspicious/,
+      /hotspot/
+    ]
+  }
+};
+var IntentClassifier = class {
+  /**
+   * Classify a natural language question into an intent.
+   *
+   * @param question - The natural language question to classify
+   * @returns ClassificationResult with intent, confidence, and per-signal scores
+   */
+  classify(question) {
+    const normalized = question.toLowerCase().trim();
+    const scores = [];
+    for (const intent of INTENTS) {
+      const signals = this.scoreIntent(normalized, INTENT_SIGNALS[intent]);
+      const confidence = this.combineSignals(signals);
+      scores.push({ intent, confidence, signals });
+    }
+    scores.sort((a, b) => b.confidence - a.confidence);
+    const best = scores[0];
+    return {
+      intent: best.intent,
+      confidence: best.confidence,
+      signals: best.signals
+    };
+  }
+  /**
+   * Score individual signals for an intent against the normalized query.
+   */
+  scoreIntent(normalized, signalSet) {
+    return {
+      keyword: this.scoreKeywords(normalized, signalSet.keywords),
+      questionWord: this.scoreQuestionWord(normalized, signalSet.questionWords),
+      verbPattern: this.scoreVerbPatterns(normalized, signalSet.verbPatterns)
+    };
+  }
+  /**
+   * Score keyword signal: uses word-stem matching (checks if any word in the
+   * query starts with the keyword). Saturates at 2 matches to avoid penalizing
+   * intents with many keywords when only a few appear in the query.
+   */
+  scoreKeywords(normalized, keywords) {
+    if (keywords.length === 0) return 0;
+    const words = normalized.split(/\s+/);
+    let matched = 0;
+    for (const keyword of keywords) {
+      if (words.some((w) => w.startsWith(keyword))) {
+        matched++;
+      }
+    }
+    return Math.min(matched / 2, 1);
+  }
+  /**
+   * Score question-word signal: 1.0 if the query starts with a matching
+   * question word, 0 otherwise.
+   */
+  scoreQuestionWord(normalized, questionWords) {
+    const firstWord = normalized.split(/\s+/)[0] ?? "";
+    return questionWords.includes(firstWord) ? 1 : 0;
+  }
+  /**
+   * Score verb-pattern signal: any matching pattern yields a strong score.
+   * Multiple matches increase score but saturate quickly.
+   */
+  scoreVerbPatterns(normalized, patterns) {
+    if (patterns.length === 0) return 0;
+    let matched = 0;
+    for (const pattern of patterns) {
+      if (pattern.test(normalized)) {
+        matched++;
+      }
+    }
+    return matched === 0 ? 0 : Math.min(0.6 + matched * 0.2, 1);
+  }
+  /**
+   * Combine individual signal scores into a single confidence score
+   * using additive weighted scoring. Each signal contributes weight * score,
+   * and the total weights sum to 1.0 so the result is naturally bounded [0, 1].
+   */
+  combineSignals(signals) {
+    let total = 0;
+    for (const key of Object.keys(signals)) {
+      const weight = SIGNAL_WEIGHTS[key];
+      total += signals[key] * weight;
+    }
+    return total;
+  }
+};
+
+// src/nlq/EntityExtractor.ts
+var INTENT_KEYWORDS = /* @__PURE__ */ new Set([
+  // impact
+  "break",
+  "breaks",
+  "affect",
+  "affects",
+  "affected",
+  "impact",
+  "change",
+  "depend",
+  "depends",
+  "blast",
+  "radius",
+  "risk",
+  "delete",
+  "remove",
+  "modify",
+  "happens",
+  // find
+  "find",
+  "where",
+  "locate",
+  "search",
+  "list",
+  "all",
+  "every",
+  "show",
+  // relationships
+  "connect",
+  "connects",
+  "call",
+  "calls",
+  "import",
+  "imports",
+  "use",
+  "uses",
+  "link",
+  "neighbor",
+  "caller",
+  "callers",
+  "callee",
+  "callees",
+  // explain
+  "describe",
+  "explain",
+  "tell",
+  "about",
+  "overview",
+  "summary",
+  "work",
+  "works",
+  // anomaly
+  "wrong",
+  "problem",
+  "problems",
+  "anomaly",
+  "anomalies",
+  "smell",
+  "smells",
+  "issue",
+  "issues",
+  "outlier",
+  "hotspot",
+  "hotspots",
+  "suspicious"
+]);
+var STOP_WORDS2 = /* @__PURE__ */ new Set([
+  "a",
+  "an",
+  "the",
+  "is",
+  "are",
+  "was",
+  "were",
+  "be",
+  "been",
+  "being",
+  "have",
+  "has",
+  "had",
+  "do",
+  "does",
+  "did",
+  "will",
+  "would",
+  "could",
+  "should",
+  "may",
+  "might",
+  "shall",
+  "can",
+  "need",
+  "must",
+  "i",
+  "me",
+  "my",
+  "we",
+  "our",
+  "you",
+  "your",
+  "he",
+  "she",
+  "it",
+  "its",
+  "they",
+  "them",
+  "their",
+  "this",
+  "that",
+  "these",
+  "those",
+  "and",
+  "or",
+  "but",
+  "if",
+  "then",
+  "else",
+  "when",
+  "while",
+  "for",
+  "of",
+  "at",
+  "by",
+  "to",
+  "in",
+  "on",
+  "with",
+  "from",
+  "up",
+  "out",
+  "not",
+  "no",
+  "nor",
+  "so",
+  "too",
+  "very",
+  "just",
+  "also",
+  "what",
+  "who",
+  "how",
+  "which",
+  "where",
+  "why",
+  "there",
+  "here",
+  "any",
+  "some",
+  "each",
+  "than",
+  "like",
+  "get",
+  "give",
+  "go",
+  "make",
+  "see",
+  "know",
+  "take"
+]);
+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;
+var EntityExtractor = class {
+  /**
+   * Extract candidate entity mentions from a natural language query.
+   *
+   * @param query - The natural language query to extract entities from
+   * @returns Array of raw entity strings in priority order, deduplicated
+   */
+  extract(query) {
+    const trimmed = query.trim();
+    if (trimmed.length === 0) return [];
+    const seen = /* @__PURE__ */ new Set();
+    const result = [];
+    const add = (entity) => {
+      if (!seen.has(entity)) {
+        seen.add(entity);
+        result.push(entity);
+      }
+    };
+    const quotedConsumed = /* @__PURE__ */ new Set();
+    for (const match of trimmed.matchAll(QUOTED_RE)) {
+      const inner = match[1].trim();
+      if (inner.length > 0) {
+        add(inner);
+        quotedConsumed.add(inner);
+      }
+    }
+    const casingConsumed = /* @__PURE__ */ new Set();
+    for (const match of trimmed.matchAll(PASCAL_OR_CAMEL_RE)) {
+      const token = match[0];
+      if (!quotedConsumed.has(token)) {
+        add(token);
+        casingConsumed.add(token);
+      }
+    }
+    const pathConsumed = /* @__PURE__ */ new Set();
+    for (const match of trimmed.matchAll(FILE_PATH_RE)) {
+      const path6 = match[0];
+      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 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;
+      add(cleaned);
+    }
+    return result;
+  }
+};
+
+// src/nlq/EntityResolver.ts
+var EntityResolver = class {
+  store;
+  fusion;
+  constructor(store, fusion) {
+    this.store = store;
+    this.fusion = fusion;
+  }
+  /**
+   * Resolve an array of raw entity strings to graph nodes.
+   *
+   * @param raws - Raw entity strings from EntityExtractor
+   * @returns Array of ResolvedEntity for each successfully resolved raw string
+   */
+  resolve(raws) {
+    const results = [];
+    for (const raw of raws) {
+      const resolved = this.resolveOne(raw);
+      if (resolved !== void 0) {
+        results.push(resolved);
+      }
+    }
+    return results;
+  }
+  resolveOne(raw) {
+    const exactMatches = this.store.findNodes({ name: raw });
+    if (exactMatches.length > 0) {
+      const node = exactMatches[0];
+      return {
+        raw,
+        nodeId: node.id,
+        node,
+        confidence: 1,
+        method: "exact"
+      };
+    }
+    if (this.fusion) {
+      const fusionResults = this.fusion.search(raw, 5);
+      if (fusionResults.length > 0 && fusionResults[0].score > 0.5) {
+        const top = fusionResults[0];
+        return {
+          raw,
+          nodeId: top.nodeId,
+          node: top.node,
+          confidence: top.score,
+          method: "fusion"
+        };
+      }
+    }
+    if (raw.length < 3) return void 0;
+    const isPathLike = raw.includes("/");
+    const fileNodes = this.store.findNodes({ type: "file" });
+    for (const node of fileNodes) {
+      if (!node.path) continue;
+      if (isPathLike && node.path.includes(raw)) {
+        return { raw, nodeId: node.id, node, confidence: 0.6, method: "path" };
+      }
+      const basename4 = node.path.split("/").pop() ?? "";
+      if (basename4.includes(raw)) {
+        return { raw, nodeId: node.id, node, confidence: 0.6, method: "path" };
+      }
+      if (raw.length >= 4 && node.path.includes(raw)) {
+        return { raw, nodeId: node.id, node, confidence: 0.6, method: "path" };
+      }
+    }
+    return void 0;
+  }
+};
+
+// src/nlq/ResponseFormatter.ts
+var ResponseFormatter = class {
+  /**
+   * Format graph operation results into a human-readable summary.
+   *
+   * @param intent - The classified intent
+   * @param entities - Resolved entities from the query
+   * @param data - Raw result data (shape varies per intent)
+   * @param query - Original natural language query (optional)
+   * @returns Human-readable summary string
+   */
+  format(intent, entities, data, query) {
+    if (data === null || data === void 0) {
+      return "No results found.";
+    }
+    const firstEntity = entities[0];
+    const entityName = firstEntity?.raw ?? "the target";
+    switch (intent) {
+      case "impact":
+        return this.formatImpact(entityName, data);
+      case "find":
+        return this.formatFind(data, query);
+      case "relationships":
+        return this.formatRelationships(entityName, entities, data);
+      case "explain":
+        return this.formatExplain(entityName, entities, data);
+      case "anomaly":
+        return this.formatAnomaly(data);
+      default:
+        return `Processed results for "${entityName}".`;
+    }
+  }
+  formatImpact(entityName, data) {
+    const d = data;
+    const code = this.safeArrayLength(d?.code);
+    const tests = this.safeArrayLength(d?.tests);
+    const docs = this.safeArrayLength(d?.docs);
+    return `Changing **${entityName}** affects ${this.p(code, "code file")}, ${this.p(tests, "test")}, and ${this.p(docs, "doc")}.`;
+  }
+  formatFind(data, query) {
+    const count = Array.isArray(data) ? data.length : 0;
+    if (query) {
+      return `Found ${this.p(count, "match", "matches")} for "${query}".`;
+    }
+    return `Found ${this.p(count, "match", "matches")}.`;
+  }
+  formatRelationships(entityName, entities, data) {
+    const d = data;
+    const edges = Array.isArray(d?.edges) ? d.edges : [];
+    const firstEntity = entities[0];
+    const rootId = firstEntity?.nodeId ?? "";
+    let outbound = 0;
+    let inbound = 0;
+    for (const edge of edges) {
+      if (edge.from === rootId) outbound++;
+      if (edge.to === rootId) inbound++;
+    }
+    return `**${entityName}** has ${outbound} outbound and ${inbound} inbound relationships.`;
+  }
+  formatExplain(entityName, entities, data) {
+    const d = data;
+    const context = Array.isArray(d?.context) ? d.context : [];
+    const firstEntity = entities[0];
+    const nodeType = firstEntity?.node.type ?? "node";
+    const path6 = firstEntity?.node.path ?? "unknown";
+    let neighborCount = 0;
+    const firstContext = context[0];
+    if (firstContext && Array.isArray(firstContext.nodes)) {
+      neighborCount = firstContext.nodes.length;
+    }
+    return `**${entityName}** is a ${nodeType} at \`${path6}\`. Connected to ${neighborCount} nodes.`;
+  }
+  formatAnomaly(data) {
+    const d = data;
+    const outliers = Array.isArray(d?.statisticalOutliers) ? d.statisticalOutliers : [];
+    const artPoints = Array.isArray(d?.articulationPoints) ? d.articulationPoints : [];
+    const count = outliers.length + artPoints.length;
+    if (count === 0) {
+      return "Found 0 anomalies.";
+    }
+    const topItems = [
+      ...outliers.slice(0, 2).map((o) => o.nodeId ?? "unknown outlier"),
+      ...artPoints.slice(0, 1).map((a) => a.nodeId ?? "unknown bottleneck")
+    ].join(", ");
+    return `Found ${this.p(count, "anomaly", "anomalies")}: ${topItems}.`;
+  }
+  safeArrayLength(value) {
+    return Array.isArray(value) ? value.length : 0;
+  }
+  p(count, singular, plural) {
+    const word = count === 1 ? singular : plural ?? singular + "s";
+    return `${count} ${word}`;
+  }
+};
+
+// src/nlq/index.ts
+var ENTITY_REQUIRED_INTENTS = /* @__PURE__ */ new Set(["impact", "relationships", "explain"]);
+var classifier = new IntentClassifier();
+var extractor = new EntityExtractor();
+var formatter = new ResponseFormatter();
+async function askGraph(store, question) {
+  const fusion = new FusionLayer(store);
+  const resolver = new EntityResolver(store, fusion);
+  const classification = classifier.classify(question);
+  if (classification.confidence < 0.3) {
+    return {
+      intent: classification.intent,
+      intentConfidence: classification.confidence,
+      entities: [],
+      summary: "I'm not sure what you're asking. Try rephrasing your question.",
+      data: null,
+      suggestions: [
+        'Try "what breaks if I change <name>?" for impact analysis',
+        'Try "where is <name>?" to find entities',
+        'Try "what calls <name>?" for relationships',
+        'Try "what is <name>?" for explanations',
+        'Try "what looks wrong?" for anomaly detection'
+      ]
+    };
+  }
+  const rawEntities = extractor.extract(question);
+  const entities = resolver.resolve(rawEntities);
+  if (ENTITY_REQUIRED_INTENTS.has(classification.intent) && entities.length === 0) {
+    return {
+      intent: classification.intent,
+      intentConfidence: classification.confidence,
+      entities: [],
+      summary: "Could not find any matching nodes in the graph for your query. Try using exact class names, function names, or file paths.",
+      data: null
+    };
+  }
+  let data;
+  try {
+    data = executeOperation(store, classification.intent, entities, question, fusion);
+  } catch (err) {
+    return {
+      intent: classification.intent,
+      intentConfidence: classification.confidence,
+      entities,
+      summary: `An error occurred while querying the graph: ${err instanceof Error ? err.message : String(err)}`,
+      data: null
+    };
+  }
+  const summary = formatter.format(classification.intent, entities, data, question);
+  return {
+    intent: classification.intent,
+    intentConfidence: classification.confidence,
+    entities,
+    summary,
+    data
+  };
+}
+function executeOperation(store, intent, entities, question, fusion) {
+  const cql = new ContextQL(store);
+  switch (intent) {
+    case "impact": {
+      const rootId = entities[0].nodeId;
+      const result = cql.execute({
+        rootNodeIds: [rootId],
+        bidirectional: true,
+        maxDepth: 3
+      });
+      return groupNodesByImpact(result.nodes, rootId);
+    }
+    case "find": {
+      return fusion.search(question, 10);
+    }
+    case "relationships": {
+      const rootId = entities[0].nodeId;
+      const result = cql.execute({
+        rootNodeIds: [rootId],
+        bidirectional: true,
+        maxDepth: 1
+      });
+      return { nodes: result.nodes, edges: result.edges };
+    }
+    case "explain": {
+      const searchResults = fusion.search(question, 10);
+      const contextBlocks = [];
+      const rootIds = entities.length > 0 ? [entities[0].nodeId] : searchResults.slice(0, 3).map((r) => r.nodeId);
+      for (const rootId of rootIds) {
+        const expanded = cql.execute({
+          rootNodeIds: [rootId],
+          maxDepth: 2
+        });
+        const matchingResult = searchResults.find((r) => r.nodeId === rootId);
+        contextBlocks.push({
+          rootNode: rootId,
+          score: matchingResult?.score ?? 1,
+          nodes: expanded.nodes,
+          edges: expanded.edges
+        });
+      }
+      return { searchResults, context: contextBlocks };
+    }
+    case "anomaly": {
+      const adapter = new GraphAnomalyAdapter(store);
+      return adapter.detect();
+    }
+    default:
+      return null;
+  }
+}
+
 // src/context/Assembler.ts
 var PHASE_NODE_TYPES = {
   implement: ["file", "function", "class", "method", "interface", "variable"],
@@ -3133,6 +3855,447 @@ var GraphFeedbackAdapter = class {
   }
 };
 
+// src/independence/TaskIndependenceAnalyzer.ts
+var DEFAULT_EDGE_TYPES = ["imports", "calls", "references"];
+var TaskIndependenceAnalyzer = class {
+  store;
+  constructor(store) {
+    this.store = store;
+  }
+  analyze(params) {
+    const { tasks } = params;
+    const depth = params.depth ?? 1;
+    const edgeTypes = params.edgeTypes ?? DEFAULT_EDGE_TYPES;
+    this.validate(tasks);
+    const useGraph = this.store != null && depth > 0;
+    const analysisLevel = useGraph ? "graph-expanded" : "file-only";
+    const originalFiles = /* @__PURE__ */ new Map();
+    const expandedFiles = /* @__PURE__ */ new Map();
+    for (const task of tasks) {
+      const origSet = new Set(task.files);
+      originalFiles.set(task.id, origSet);
+      if (useGraph) {
+        const expanded = this.expandViaGraph(task.files, depth, edgeTypes);
+        expandedFiles.set(task.id, expanded);
+      } else {
+        expandedFiles.set(task.id, /* @__PURE__ */ new Map());
+      }
+    }
+    const taskIds = tasks.map((t) => t.id);
+    const pairs = [];
+    for (let i = 0; i < taskIds.length; i++) {
+      for (let j = i + 1; j < taskIds.length; j++) {
+        const idA = taskIds[i];
+        const idB = taskIds[j];
+        const pair = this.computePairOverlap(
+          idA,
+          idB,
+          originalFiles.get(idA),
+          originalFiles.get(idB),
+          expandedFiles.get(idA),
+          expandedFiles.get(idB)
+        );
+        pairs.push(pair);
+      }
+    }
+    const groups = this.buildGroups(taskIds, pairs);
+    const verdict = this.generateVerdict(taskIds, groups, analysisLevel);
+    return {
+      tasks: taskIds,
+      analysisLevel,
+      depth,
+      pairs,
+      groups,
+      verdict
+    };
+  }
+  // --- Private methods ---
+  validate(tasks) {
+    if (tasks.length < 2) {
+      throw new Error("At least 2 tasks are required for independence analysis");
+    }
+    const seenIds = /* @__PURE__ */ new Set();
+    for (const task of tasks) {
+      if (seenIds.has(task.id)) {
+        throw new Error(`Duplicate task ID: "${task.id}"`);
+      }
+      seenIds.add(task.id);
+      if (task.files.length === 0) {
+        throw new Error(`Task "${task.id}" has an empty files array`);
+      }
+    }
+  }
+  expandViaGraph(files, depth, edgeTypes) {
+    const result = /* @__PURE__ */ new Map();
+    const store = this.store;
+    const cql = new ContextQL(store);
+    const fileSet = new Set(files);
+    for (const file of files) {
+      const nodeId = `file:${file}`;
+      const node = store.getNode(nodeId);
+      if (!node) continue;
+      const queryResult = cql.execute({
+        rootNodeIds: [nodeId],
+        maxDepth: depth,
+        includeEdges: edgeTypes,
+        includeTypes: ["file"]
+      });
+      for (const n of queryResult.nodes) {
+        const path6 = n.path ?? n.id.replace(/^file:/, "");
+        if (!fileSet.has(path6)) {
+          if (!result.has(path6)) {
+            result.set(path6, file);
+          }
+        }
+      }
+    }
+    return result;
+  }
+  computePairOverlap(idA, idB, origA, origB, expandedA, expandedB) {
+    const overlaps = [];
+    for (const file of origA) {
+      if (origB.has(file)) {
+        overlaps.push({ file, type: "direct" });
+      }
+    }
+    const directFiles = new Set(overlaps.map((o) => o.file));
+    const transitiveFiles = /* @__PURE__ */ new Set();
+    for (const [file, via] of expandedA) {
+      if (origB.has(file) && !directFiles.has(file) && !transitiveFiles.has(file)) {
+        transitiveFiles.add(file);
+        overlaps.push({ file, type: "transitive", via });
+      }
+    }
+    for (const [file, via] of expandedB) {
+      if (origA.has(file) && !directFiles.has(file) && !transitiveFiles.has(file)) {
+        transitiveFiles.add(file);
+        overlaps.push({ file, type: "transitive", via });
+      }
+    }
+    for (const [file, viaA] of expandedA) {
+      if (expandedB.has(file) && !directFiles.has(file) && !transitiveFiles.has(file)) {
+        transitiveFiles.add(file);
+        overlaps.push({ file, type: "transitive", via: viaA });
+      }
+    }
+    return {
+      taskA: idA,
+      taskB: idB,
+      independent: overlaps.length === 0,
+      overlaps
+    };
+  }
+  buildGroups(taskIds, pairs) {
+    const parent = /* @__PURE__ */ new Map();
+    const rank = /* @__PURE__ */ new Map();
+    for (const id of taskIds) {
+      parent.set(id, id);
+      rank.set(id, 0);
+    }
+    const find = (x) => {
+      let root = x;
+      while (parent.get(root) !== root) {
+        root = parent.get(root);
+      }
+      let current = x;
+      while (current !== root) {
+        const next = parent.get(current);
+        parent.set(current, root);
+        current = next;
+      }
+      return root;
+    };
+    const union = (a, b) => {
+      const rootA = find(a);
+      const rootB = find(b);
+      if (rootA === rootB) return;
+      const rankA = rank.get(rootA);
+      const rankB = rank.get(rootB);
+      if (rankA < rankB) {
+        parent.set(rootA, rootB);
+      } else if (rankA > rankB) {
+        parent.set(rootB, rootA);
+      } else {
+        parent.set(rootB, rootA);
+        rank.set(rootA, rankA + 1);
+      }
+    };
+    for (const pair of pairs) {
+      if (!pair.independent) {
+        union(pair.taskA, pair.taskB);
+      }
+    }
+    const groupMap = /* @__PURE__ */ new Map();
+    for (const id of taskIds) {
+      const root = find(id);
+      if (!groupMap.has(root)) {
+        groupMap.set(root, []);
+      }
+      groupMap.get(root).push(id);
+    }
+    return Array.from(groupMap.values());
+  }
+  generateVerdict(taskIds, groups, analysisLevel) {
+    const total = taskIds.length;
+    const groupCount = groups.length;
+    let verdict;
+    if (groupCount === 1) {
+      verdict = `All ${total} tasks conflict \u2014 must run serially.`;
+    } else if (groupCount === total) {
+      verdict = `All ${total} tasks are independent \u2014 can all run in parallel.`;
+    } else {
+      verdict = `${total} tasks form ${groupCount} independent groups \u2014 ${groupCount} parallel waves possible.`;
+    }
+    if (analysisLevel === "file-only") {
+      verdict += " Graph unavailable \u2014 transitive dependencies not checked.";
+    }
+    return verdict;
+  }
+};
+
+// src/independence/ConflictPredictor.ts
+var ConflictPredictor = class {
+  store;
+  constructor(store) {
+    this.store = store;
+  }
+  predict(params) {
+    const analyzer = new TaskIndependenceAnalyzer(this.store);
+    const result = analyzer.analyze(params);
+    const churnMap = /* @__PURE__ */ new Map();
+    const couplingMap = /* @__PURE__ */ new Map();
+    let churnThreshold = Infinity;
+    let couplingThreshold = Infinity;
+    if (this.store != null) {
+      const complexityResult = new GraphComplexityAdapter(this.store).computeComplexityHotspots();
+      for (const hotspot of complexityResult.hotspots) {
+        const existing = churnMap.get(hotspot.file);
+        if (existing === void 0 || hotspot.changeFrequency > existing) {
+          churnMap.set(hotspot.file, hotspot.changeFrequency);
+        }
+      }
+      const couplingResult = new GraphCouplingAdapter(this.store).computeCouplingData();
+      for (const fileData of couplingResult.files) {
+        couplingMap.set(fileData.file, fileData.fanIn + fileData.fanOut);
+      }
+      churnThreshold = this.computePercentile(Array.from(churnMap.values()), 80);
+      couplingThreshold = this.computePercentile(Array.from(couplingMap.values()), 80);
+    }
+    const conflicts = [];
+    for (const pair of result.pairs) {
+      if (pair.independent) continue;
+      const { severity, reason, mitigation } = this.classifyPair(
+        pair.taskA,
+        pair.taskB,
+        pair.overlaps,
+        churnMap,
+        couplingMap,
+        churnThreshold,
+        couplingThreshold
+      );
+      conflicts.push({
+        taskA: pair.taskA,
+        taskB: pair.taskB,
+        severity,
+        reason,
+        mitigation,
+        overlaps: pair.overlaps
+      });
+    }
+    const taskIds = result.tasks;
+    const groups = this.buildHighSeverityGroups(taskIds, conflicts);
+    const regrouped = !this.groupsEqual(result.groups, groups);
+    let highCount = 0;
+    let mediumCount = 0;
+    let lowCount = 0;
+    for (const c of conflicts) {
+      if (c.severity === "high") highCount++;
+      else if (c.severity === "medium") mediumCount++;
+      else lowCount++;
+    }
+    const verdict = this.generateVerdict(
+      taskIds,
+      groups,
+      result.analysisLevel,
+      highCount,
+      mediumCount,
+      lowCount,
+      regrouped
+    );
+    return {
+      tasks: taskIds,
+      analysisLevel: result.analysisLevel,
+      depth: result.depth,
+      conflicts,
+      groups,
+      summary: {
+        high: highCount,
+        medium: mediumCount,
+        low: lowCount,
+        regrouped
+      },
+      verdict
+    };
+  }
+  // --- Private helpers ---
+  classifyPair(taskA, taskB, overlaps, churnMap, couplingMap, churnThreshold, couplingThreshold) {
+    let maxSeverity = "low";
+    let primaryReason = "";
+    let primaryMitigation = "";
+    for (const overlap of overlaps) {
+      let overlapSeverity;
+      let reason;
+      let mitigation;
+      if (overlap.type === "direct") {
+        overlapSeverity = "high";
+        reason = `Both tasks write to ${overlap.file}`;
+        mitigation = `Serialize: run ${taskA} before ${taskB}`;
+      } else {
+        const churn = churnMap.get(overlap.file);
+        const coupling = couplingMap.get(overlap.file);
+        const via = overlap.via ?? "unknown";
+        if (churn !== void 0 && churn >= churnThreshold && churnThreshold !== Infinity) {
+          overlapSeverity = "medium";
+          reason = `Transitive overlap on high-churn file ${overlap.file} (via ${via})`;
+          mitigation = `Review: ${overlap.file} changes frequently \u2014 coordinate edits between ${taskA} and ${taskB}`;
+        } else if (coupling !== void 0 && coupling >= couplingThreshold && couplingThreshold !== Infinity) {
+          overlapSeverity = "medium";
+          reason = `Transitive overlap on highly-coupled file ${overlap.file} (via ${via})`;
+          mitigation = `Review: ${overlap.file} has high coupling \u2014 coordinate edits between ${taskA} and ${taskB}`;
+        } else {
+          overlapSeverity = "low";
+          reason = `Transitive overlap on ${overlap.file} (via ${via}) \u2014 low risk`;
+          mitigation = `Info: transitive overlap unlikely to cause conflicts`;
+        }
+      }
+      if (this.severityRank(overlapSeverity) > this.severityRank(maxSeverity)) {
+        maxSeverity = overlapSeverity;
+        primaryReason = reason;
+        primaryMitigation = mitigation;
+      } else if (primaryReason === "") {
+        primaryReason = reason;
+        primaryMitigation = mitigation;
+      }
+    }
+    return { severity: maxSeverity, reason: primaryReason, mitigation: primaryMitigation };
+  }
+  severityRank(severity) {
+    switch (severity) {
+      case "high":
+        return 3;
+      case "medium":
+        return 2;
+      case "low":
+        return 1;
+    }
+  }
+  computePercentile(values, percentile) {
+    if (values.length === 0) return Infinity;
+    const sorted = [...values].sort((a, b) => a - b);
+    const index = Math.ceil(percentile / 100 * sorted.length) - 1;
+    return sorted[Math.min(index, sorted.length - 1)];
+  }
+  buildHighSeverityGroups(taskIds, conflicts) {
+    const parent = /* @__PURE__ */ new Map();
+    const rank = /* @__PURE__ */ new Map();
+    for (const id of taskIds) {
+      parent.set(id, id);
+      rank.set(id, 0);
+    }
+    const find = (x) => {
+      let root = x;
+      while (parent.get(root) !== root) {
+        root = parent.get(root);
+      }
+      let current = x;
+      while (current !== root) {
+        const next = parent.get(current);
+        parent.set(current, root);
+        current = next;
+      }
+      return root;
+    };
+    const union = (a, b) => {
+      const rootA = find(a);
+      const rootB = find(b);
+      if (rootA === rootB) return;
+      const rankA = rank.get(rootA);
+      const rankB = rank.get(rootB);
+      if (rankA < rankB) {
+        parent.set(rootA, rootB);
+      } else if (rankA > rankB) {
+        parent.set(rootB, rootA);
+      } else {
+        parent.set(rootB, rootA);
+        rank.set(rootA, rankA + 1);
+      }
+    };
+    for (const conflict of conflicts) {
+      if (conflict.severity === "high") {
+        union(conflict.taskA, conflict.taskB);
+      }
+    }
+    const groupMap = /* @__PURE__ */ new Map();
+    for (const id of taskIds) {
+      const root = find(id);
+      let group = groupMap.get(root);
+      if (group === void 0) {
+        group = [];
+        groupMap.set(root, group);
+      }
+      group.push(id);
+    }
+    return Array.from(groupMap.values());
+  }
+  groupsEqual(a, b) {
+    if (a.length !== b.length) return false;
+    const normalize2 = (groups) => groups.map((g) => [...g].sort()).sort((x, y) => {
+      const xFirst = x[0];
+      const yFirst = y[0];
+      return xFirst.localeCompare(yFirst);
+    });
+    const normA = normalize2(a);
+    const normB = normalize2(b);
+    for (let i = 0; i < normA.length; i++) {
+      const groupA = normA[i];
+      const groupB = normB[i];
+      if (groupA.length !== groupB.length) return false;
+      for (let j = 0; j < groupA.length; j++) {
+        if (groupA[j] !== groupB[j]) return false;
+      }
+    }
+    return true;
+  }
+  generateVerdict(taskIds, groups, analysisLevel, highCount, mediumCount, lowCount, regrouped) {
+    const total = taskIds.length;
+    const groupCount = groups.length;
+    const parts = [];
+    const conflictParts = [];
+    if (highCount > 0) conflictParts.push(`${highCount} high`);
+    if (mediumCount > 0) conflictParts.push(`${mediumCount} medium`);
+    if (lowCount > 0) conflictParts.push(`${lowCount} low`);
+    if (conflictParts.length === 0) {
+      parts.push(`${total} tasks have no conflicts \u2014 can all run in parallel.`);
+    } else {
+      parts.push(`${total} tasks have ${conflictParts.join(", ")} severity conflicts.`);
+    }
+    if (groupCount === 1) {
+      parts.push(`All tasks must run serially.`);
+    } else if (groupCount === total) {
+      parts.push(`${groupCount} parallel groups (all independent).`);
+    } else {
+      parts.push(`${groupCount} parallel groups possible.`);
+    }
+    if (regrouped) {
+      parts.push(`Tasks were regrouped due to high-severity conflicts.`);
+    }
+    if (analysisLevel === "file-only") {
+      parts.push(`Graph unavailable \u2014 severity based on file overlaps only.`);
+    }
+    return parts.join(" ");
+  }
+};
+
 // src/index.ts
 var VERSION = "0.2.0";
 // Annotate the CommonJS export names for ESM import in node:
@@ -3141,11 +4304,14 @@ var VERSION = "0.2.0";
   CIConnector,
   CURRENT_SCHEMA_VERSION,
   CodeIngestor,
+  ConflictPredictor,
   ConfluenceConnector,
   ContextQL,
   DesignConstraintAdapter,
   DesignIngestor,
   EDGE_TYPES,
+  EntityExtractor,
+  EntityResolver,
   FusionLayer,
   GitIngestor,
   GraphAnomalyAdapter,
@@ -3157,15 +4323,21 @@ var VERSION = "0.2.0";
   GraphFeedbackAdapter,
   GraphNodeSchema,
   GraphStore,
+  INTENTS,
+  IntentClassifier,
   JiraConnector,
   KnowledgeIngestor,
   NODE_TYPES,
   OBSERVABILITY_TYPES,
+  ResponseFormatter,
   SlackConnector,
   SyncManager,
+  TaskIndependenceAnalyzer,
   TopologicalLinker,
   VERSION,
   VectorStore,
+  askGraph,
+  groupNodesByImpact,
   linkToCode,
   loadGraph,
   project,