@lowgular/code-graph 0.1.1 → 0.1.2

package/lib.js

@@ -0,0 +1,2430 @@
+// libs/cli/code-graph-core/src/lib/code-graph-v2/config-from-query.ts
+var STANDARD_NODE_PROPERTIES = {
+  firstIdentifier: `helpers.getDescendantsBy(args.current, (node) => node.kind === args.ts.SyntaxKind.Identifier)[0]?.getText() ?? null`,
+  initializer: `args.current.initializer ? args.current.initializer?.getText() : null`,
+  name: `args.current.name?.getText() ?? null`,
+  filePath: `args.sourceFile.fileName`,
+  text: `args.current.getText()`,
+  type: `(() => { try { const t = args.typeChecker.getTypeAtLocation(args.current); return t ? args.typeChecker.typeToString(t) : null; } catch { return null; } })()`
+};
+var SUPPORTED_RELATIONSHIPS = {
+  // --- Traversal relationships ---
+  HAS_DESCENDANTS: (labels) => labels.length > 0 ? `helpers.getDescendantsBy(args.current, (node) => ${buildKindFilter(labels)})` : `helpers.getDescendantsBy(args.current, () => true)`,
+  HAS_ANCESTORS: (labels) => labels.length > 0 ? `helpers.getAncestorsBy(args.current, (node) => ${buildKindFilter(labels)})` : `helpers.getAncestorsBy(args.current, () => true)`,
+  HAS_TYPE: () => `helpers.getType(args.current)`,
+  HAS_NAME: () => `args.current.name ? [args.current.name] : []`,
+  // --- Direct AST property relationships ---
+  HAS_INITIALIZER: () => `args.current.initializer ? [args.current.initializer] : []`,
+  HAS_PARAMETERS: () => `args.current.parameters ? [...args.current.parameters] : []`,
+  HAS_EXPRESSION: () => `args.current.expression ? [args.current.expression] : []`,
+  HAS_TYPE_ANNOTATION: () => `args.current.type ? [args.current.type] : []`,
+  HAS_BODY: () => `args.current.body ? [args.current.body] : []`,
+  HAS_MEMBERS: () => `args.current.members ? [...args.current.members] : []`,
+  HAS_PROPERTIES: () => `args.current.properties ? [...args.current.properties] : []`,
+  HAS_ARGUMENTS: () => `args.current.arguments ? [...args.current.arguments] : []`,
+  HAS_DECORATORS: () => `args.ts.getDecorators(args.current) || []`,
+  // --- Heritage relationships ---
+  EXTENDS: () => `(() => { const c = (args.current.heritageClauses || []).find(c => c.token === args.ts.SyntaxKind.ExtendsKeyword); return c ? [...c.types] : []; })()`,
+  IMPLEMENTS: () => `(() => { const c = (args.current.heritageClauses || []).find(c => c.token === args.ts.SyntaxKind.ImplementsKeyword); return c ? [...c.types] : []; })()`
+};
+var buildConfigFromQuery = (query2) => {
+  const nodeExtractors = {};
+  const matchStatements = query2.statements.filter(
+    (s) => s.type === "MatchStatement"
+  );
+  const variableToLabels = {};
+  for (const match of matchStatements) {
+    for (const pattern of match.patterns) {
+      if (pattern.variable && pattern.labels.length > 0) {
+        variableToLabels[pattern.variable] = pattern.labels;
+      }
+    }
+  }
+  for (const match of matchStatements) {
+    buildExtractorsFromMatch(match, nodeExtractors, variableToLabels);
+  }
+  return { nodeExtractors };
+};
+var resolveLabels = (pattern, variableToLabels) => {
+  if (pattern.labels.length > 0)
+    return pattern.labels;
+  if (pattern.variable && variableToLabels[pattern.variable]) {
+    return variableToLabels[pattern.variable];
+  }
+  return [];
+};
+var buildExtractorsFromMatch = (match, rootNodeExtractors, variableToLabels) => {
+  const { patterns, relationships } = match;
+  if (patterns.length === 0)
+    return;
+  const rootPattern = patterns[0];
+  const rootLabels = resolveLabels(rootPattern, variableToLabels);
+  for (const label of rootLabels) {
+    rootNodeExtractors[label] ??= {
+      properties: { ...STANDARD_NODE_PROPERTIES }
+    };
+  }
+  if (!relationships || relationships.length === 0)
+    return;
+  let currentExtractors = rootNodeExtractors;
+  for (let i = 0; i < relationships.length; i++) {
+    const rel = relationships[i];
+    const sourcePattern = patterns[i];
+    const targetPattern = patterns[i + 1];
+    if (!targetPattern)
+      break;
+    const edgeType = resolveEdgeType(rel.edgeType);
+    const codeGenerator = getCodeGenerator(edgeType);
+    const sourceLabels = resolveLabels(sourcePattern, variableToLabels);
+    const targetLabels = resolveLabels(targetPattern, variableToLabels);
+    const targetNodeExtractors = {};
+    if (targetLabels.length === 0) {
+      targetNodeExtractors["*"] = {
+        properties: { ...STANDARD_NODE_PROPERTIES }
+      };
+    } else {
+      for (const label of targetLabels) {
+        targetNodeExtractors[label] = {
+          properties: { ...STANDARD_NODE_PROPERTIES }
+        };
+      }
+    }
+    for (const sourceLabel of sourceLabels) {
+      currentExtractors[sourceLabel] ??= {
+        properties: { ...STANDARD_NODE_PROPERTIES }
+      };
+      currentExtractors[sourceLabel].relationships ??= {};
+      currentExtractors[sourceLabel].relationships[edgeType] = {
+        extractorCode: codeGenerator(targetLabels),
+        nodeExtractors: targetNodeExtractors
+      };
+    }
+    currentExtractors = targetNodeExtractors;
+  }
+};
+var resolveEdgeType = (edgeType) => {
+  if (!edgeType) {
+    throw new Error(
+      `Relationship type is required in auto-config mode. Supported: ${Object.keys(SUPPORTED_RELATIONSHIPS).join(", ")}`
+    );
+  }
+  if (Array.isArray(edgeType)) {
+    throw new Error(
+      `Union relationship types are not supported in auto-config. Got: ${edgeType.join("|")}`
+    );
+  }
+  return edgeType;
+};
+var getCodeGenerator = (edgeType) => {
+  const generator = SUPPORTED_RELATIONSHIPS[edgeType];
+  if (!generator) {
+    throw new Error(
+      `Unsupported relationship type: "${edgeType}". Auto-config supports: ${Object.keys(SUPPORTED_RELATIONSHIPS).join(", ")}`
+    );
+  }
+  return generator;
+};
+var buildKindFilter = (labels) => {
+  return labels.map((l) => `node.kind === args.ts.SyntaxKind.${l}`).join(" || ");
+};
+
+// libs/cli/code-graph-core/src/lib/code-graph-v2/extractors/extractor.ts
+function executeExtractor(code, context) {
+  try {
+    const fn = new Function(
+      ...Object.keys(context),
+      `
+      return ${code}
+      `
+    );
+    return fn(...Object.values(context));
+  } catch (error) {
+    throw new Error(`Extractor execution failed: ${error.message}`);
+  }
+}
+function extractNodeProperties(context, propertyExectorMap = {}) {
+  const properties = {};
+  for (const [propertyName, extractorCode] of Object.entries(
+    propertyExectorMap
+  )) {
+    const value = executeExtractor(extractorCode, context);
+    properties[propertyName] = value;
+  }
+  return properties;
+}
+
+// libs/cli/code-graph-core/src/lib/code-graph-v2/graph-builder/code-graph.builder.ts
+import * as ts7 from "typescript";
+
+// libs/cli/code-graph-core/src/lib/codegular/node.ts
+import * as ts3 from "typescript";
+
+// libs/cli/code-graph-core/src/lib/codegular/string.ts
+import * as ts2 from "typescript";
+
+// libs/cli/code-graph-core/src/lib/codegular/utils.ts
+import * as ts from "typescript";
+var { forEachChild: forEachChild2, SyntaxKind } = ts;
+function getAncestorsBy(node, predicate) {
+  let currentNode = node;
+  const nodes = [];
+  while (currentNode) {
+    if (predicate(currentNode)) {
+      nodes.push(currentNode);
+    }
+    const parent = currentNode?.parent;
+    if (!parent) {
+      break;
+    }
+    currentNode = parent;
+  }
+  return nodes;
+}
+function getDescendantsBy(node, predicate) {
+  let foundElements = [];
+  let queue = [node];
+  while (queue.length > 0) {
+    const currentNode = queue.shift();
+    const children = Array.from(
+      currentNode?.getChildren(node.getSourceFile()) || []
+    );
+    foundElements = [
+      ...foundElements,
+      ...children.filter((node2) => predicate(node2))
+    ];
+    queue = [...queue, ...children];
+  }
+  return foundElements;
+}
+function getDescendantsByKind(node, kind) {
+  return getDescendantsBy(node, (node2) => node2.kind === kind);
+}
+var getSolutionSourceFiles = (program) => {
+  const allSourceFiles = program.getSourceFiles();
+  const sourceFiles = allSourceFiles.filter((sourceFile) => {
+    const fileName = sourceFile.fileName;
+    if (fileName.includes("node_modules")) {
+      return false;
+    }
+    if (fileName.endsWith(".d.ts")) {
+      return false;
+    }
+    return true;
+  });
+  return sourceFiles;
+};
+
+// libs/cli/code-graph-core/src/lib/codegular/string.ts
+var { SyntaxKind: SyntaxKind3 } = ts2;
+
+// libs/cli/code-graph-core/src/lib/codegular/node.ts
+var { forEachChild: forEachChild3, SyntaxKind: SyntaxKind4 } = ts3;
+
+// libs/cli/code-graph-core/src/lib/codegular/program.ts
+import * as path from "path";
+import * as ts4 from "typescript";
+var createProgramFromFileSystem = (fileSystem) => {
+  const compilerOptions = {
+    target: ts4.ScriptTarget.ES2020,
+    module: ts4.ModuleKind.CommonJS,
+    moduleResolution: ts4.ModuleResolutionKind.NodeJs,
+    allowSyntheticDefaultImports: true,
+    esModuleInterop: true,
+    skipLibCheck: true,
+    lib: ["ES2020", "DOM"]
+  };
+  const compilerHost = ts4.createCompilerHost(compilerOptions);
+  const originalGetSourceFile = compilerHost.getSourceFile;
+  compilerHost.getSourceFile = (fileName, languageVersion) => {
+    if (fileSystem[fileName]) {
+      return ts4.createSourceFile(
+        fileName,
+        fileSystem[fileName],
+        languageVersion,
+        true
+      );
+    }
+    return originalGetSourceFile(fileName, languageVersion);
+  };
+  const fileNames = Object.keys(fileSystem);
+  return ts4.createProgram(fileNames, compilerOptions, compilerHost);
+};
+var createProgramFromTsConfig = (configPath) => {
+  const configFile = ts4.readConfigFile(configPath, ts4.sys.readFile);
+  if (configFile.error) {
+    const errorMessage = ts4.formatDiagnostic(configFile.error, {
+      getCurrentDirectory: () => process.cwd(),
+      getNewLine: () => "\n",
+      getCanonicalFileName: (fileName) => fileName
+    });
+    throw new Error(`Error reading tsconfig at ${configPath}: ${errorMessage}`);
+  }
+  const parsedConfig = ts4.parseJsonConfigFileContent(
+    configFile.config,
+    ts4.sys,
+    path.dirname(configPath)
+  );
+  return ts4.createProgram(
+    parsedConfig.fileNames,
+    parsedConfig.options,
+    ts4.createCompilerHost(parsedConfig.options)
+  );
+};
+
+// libs/cli/code-graph-core/src/lib/codegular/type-checker.ts
+import * as ts5 from "typescript";
+
+// libs/cli/code-graph-core/src/lib/code-graph-v2/code.graph.ts
+var addNode = (graph, node) => {
+  graph.nodesById[node.id] = node;
+  return graph;
+};
+var getEdgeKey = (edge) => {
+  return `${edge.source}|${edge.target}|${edge.type}`;
+};
+var addEdge = (graph, edge) => {
+  const edgeKey = getEdgeKey(edge);
+  const sourceEdges = graph.edgesBySource[edge.source];
+  if (sourceEdges) {
+    const sourceEdgeKeys = new Set(sourceEdges.map(getEdgeKey));
+    if (sourceEdgeKeys.has(edgeKey)) {
+      return graph;
+    }
+  }
+  const targetEdges = graph.edgesByTarget[edge.target];
+  if (targetEdges) {
+    const targetEdgeKeys = new Set(targetEdges.map(getEdgeKey));
+    if (targetEdgeKeys.has(edgeKey)) {
+      return graph;
+    }
+  }
+  if (!graph.edgesBySource[edge.source]) {
+    graph.edgesBySource[edge.source] = [];
+  }
+  graph.edgesBySource[edge.source].push(edge);
+  if (!graph.edgesByTarget[edge.target]) {
+    graph.edgesByTarget[edge.target] = [];
+  }
+  graph.edgesByTarget[edge.target].push(edge);
+  return graph;
+};
+
+// libs/cli/code-graph-core/src/lib/code-graph-v2/utils.ts
+import * as ts6 from "typescript";
+var getSyntaxKindName = (kind) => {
+  return ts6.SyntaxKind[kind];
+};
+var generateNodeId = (n) => {
+  const s = n.getSourceFile();
+  const start = s.getLineAndCharacterOfPosition(n.getStart(s));
+  const end = s.getLineAndCharacterOfPosition(n.getEnd());
+  return `${s.fileName}.${start.line}.${start.character}.${end.line}.${end.character}`;
+};
+var extractFromNodeId = (nodeId) => {
+  const parts = nodeId.split(".");
+  const endCharacter = parts.pop();
+  const endLine = parts.pop();
+  const startCharacter = parts.pop();
+  const startLine = parts.pop();
+  const filePath = parts.join(".");
+  return {
+    filePath,
+    start: {
+      line: parseInt(startLine),
+      character: parseInt(startCharacter)
+    },
+    end: {
+      line: parseInt(endLine),
+      character: parseInt(endCharacter)
+    }
+  };
+};
+
+// libs/cli/code-graph-core/src/lib/code-graph-v2/graph-builder/type.processor.ts
+var processType = (context, nodeExtractors, codeGraph) => {
+  const nodeId = context.args.typeChecker.typeToString(
+    context.args.current
+  );
+  const kindName = "Type";
+  const nodeConfig = nodeExtractors[kindName];
+  const graphNode = {
+    ...nodeConfig && nodeConfig.properties ? extractNodeProperties(context, nodeConfig.properties) : {},
+    id: nodeId,
+    labels: [kindName]
+  };
+  addNode(codeGraph, graphNode);
+  processRelationships(nodeId, context, nodeConfig, codeGraph);
+  return graphNode;
+};
+
+// libs/cli/code-graph-core/src/lib/code-graph-v2/graph-builder/relationship.processor.ts
+function isTsNode(obj) {
+  return obj && "kind" in obj && typeof obj.kind === "number";
+}
+function isTsType(obj) {
+  return obj && "flags" in obj && typeof obj.flags === "number" && !("kind" in obj);
+}
+var processRelationships = (parentId, context, nodeConfig, codeGraph) => {
+  if (nodeConfig?.relationships) {
+    for (const relationshipName of Object.keys(nodeConfig.relationships)) {
+      const relationshipExtractorFnCode = nodeConfig.relationships[relationshipName].extractorCode;
+      const relationshipNodeExtractors = nodeConfig.relationships[relationshipName].nodeExtractors;
+      Object.keys(relationshipNodeExtractors).forEach((label) => {
+        const children = executeExtractor(relationshipExtractorFnCode, context);
+        children.forEach(
+          (child) => {
+            if (isTsType(child)) {
+              const childNode = processType(
+                { ...context, args: { ...context.args, current: child } },
+                relationshipNodeExtractors,
+                codeGraph
+              );
+              addEdge(codeGraph, {
+                source: parentId,
+                target: childNode.id,
+                type: relationshipName
+              });
+            } else if (isTsNode(child)) {
+              const childNode = processNode(
+                { ...context, args: { ...context.args, current: child } },
+                relationshipNodeExtractors,
+                codeGraph
+              );
+              addEdge(codeGraph, {
+                source: parentId,
+                target: childNode.id,
+                type: relationshipName
+              });
+            } else {
+              throw new Error(
+                `The code provided: ${relationshipExtractorFnCode} returned an invalid child: ${child}. We support only ts.Node and ts.Type array returns from executed code`
+              );
+            }
+          }
+        );
+      });
+    }
+  }
+};
+
+// libs/cli/code-graph-core/src/lib/code-graph-v2/graph-builder/node.processor.ts
+var processNode = (context, nodeExtractors, codeGraph) => {
+  const nodeId = generateNodeId(context.args.current);
+  const kindName = getSyntaxKindName(context.args.current.kind);
+  const nodeConfig = nodeExtractors[kindName] ?? nodeExtractors["*"];
+  const graphNode = {
+    ...nodeConfig && nodeConfig.properties ? extractNodeProperties(context, nodeConfig.properties) : {},
+    id: nodeId,
+    labels: [kindName]
+  };
+  addNode(codeGraph, graphNode);
+  processRelationships(nodeId, context, nodeConfig, codeGraph);
+  return graphNode;
+};
+
+// libs/cli/code-graph-core/src/lib/code-graph-v2/graph-builder/code-graph.builder.ts
+var buildCodeGraph = (program, config) => {
+  const codeGraph = {
+    nodesById: {},
+    edgesBySource: {},
+    edgesByTarget: {}
+  };
+  const sourceFiles = getSolutionSourceFiles(program);
+  sourceFiles.forEach((sourceFile) => {
+    Object.keys(config.nodeExtractors).forEach((kindName) => {
+      const nodes = getDescendantsByKind(sourceFile, ts7.SyntaxKind[kindName]);
+      nodes.forEach((node) => {
+        const extractorContext = {
+          args: {
+            current: node,
+            sourceFile,
+            typeChecker: program.getTypeChecker(),
+            ts: ts7
+          },
+          helpers: {
+            getDescendantsBy,
+            getAncestorsBy,
+            getType: (node2) => []
+            // TODO: add type extraction
+            // getType(
+            //   node,
+            //   program.getTypeChecker(),
+            //   new TypeResolutionTracker(),
+            // ),
+            // getDeclarations: (node: ts.Type | ts.Node) =>
+            //   getDeclarations(node, context.typeChecker),
+          }
+        };
+        processNode(extractorContext, config.nodeExtractors, codeGraph);
+      });
+    });
+  });
+  return codeGraph;
+};
+
+// libs/cli/code-graph-core/src/lib/cypher/lib/executor/condition-evaluator.ts
+var ConditionEvaluator = class {
+  // @TODO: apply where at match level
+  /**
+   * Apply WHERE clause filtering to matches
+   */
+  applyWhereClauseIfNeeded(matches, where) {
+    return matches.filter((match) => {
+      const conditionResults = where.conditions.map(
+        (condition) => this.evaluateCondition(match, condition)
+      );
+      const logic = where.logic || "AND";
+      if (logic === "AND") {
+        return conditionResults.every((result) => result === true);
+      } else {
+        return conditionResults.some((result) => result === true);
+      }
+    });
+  }
+  // @fixme move to utils
+  /**
+   * Escape special regex characters in a string
+   */
+  escapeRegex(str) {
+    return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  }
+  /**
+   * Evaluate a single WHERE condition
+   * Supports flat properties only (no nesting, like Neo4j Cypher)
+   * Handles null values from optional matches (null values fail the condition)
+   */
+  evaluateCondition(match, condition) {
+    const value = match[condition.variable];
+    if ((condition.operator === "IS NULL" || condition.operator === "IS NOT NULL") && !condition.property) {
+      const isNull = value === null || value === void 0;
+      return condition.operator === "IS NULL" ? isNull : !isNull;
+    }
+    if (!value || value === null) {
+      return false;
+    }
+    let baseObject;
+    if ("id" in value) {
+      baseObject = value;
+    } else if ("type" in value && "source" in value) {
+      baseObject = value;
+    } else {
+      return false;
+    }
+    let actualValue;
+    if (!condition.property) {
+      actualValue = baseObject;
+    } else {
+      actualValue = baseObject[condition.property];
+      if (actualValue === void 0) {
+        if (condition.operator === "IS NULL" || condition.operator === "IS NOT NULL") {
+          actualValue = void 0;
+        } else {
+          return false;
+        }
+      }
+    }
+    const conditionValue = condition.value;
+    switch (condition.operator) {
+      case "=":
+        return actualValue === conditionValue;
+      case "!=":
+        return actualValue !== conditionValue;
+      case ">":
+        return actualValue > conditionValue;
+      case "<":
+        return actualValue < conditionValue;
+      case ">=":
+        return actualValue >= conditionValue;
+      case "<=":
+        return actualValue <= conditionValue;
+      case "IS NULL":
+        return actualValue === null || actualValue === void 0;
+      case "IS NOT NULL":
+        return actualValue !== null && actualValue !== void 0;
+      case "IN":
+        if (Array.isArray(conditionValue)) {
+          if (conditionValue.length > 0 && typeof conditionValue[0] === "object" && conditionValue[0] !== null) {
+            const extractedValues = conditionValue.map((item) => item?.name).filter((name) => name !== void 0);
+            return extractedValues.includes(actualValue);
+          }
+          return conditionValue.includes(actualValue);
+        }
+        return false;
+      case "NOT IN":
+        if (Array.isArray(conditionValue)) {
+          if (conditionValue.length > 0 && typeof conditionValue[0] === "object" && conditionValue[0] !== null) {
+            const extractedValues = conditionValue.map((item) => item?.name).filter((name) => name !== void 0);
+            return !extractedValues.includes(actualValue);
+          }
+          return !conditionValue.includes(actualValue);
+        }
+        return true;
+      case "STARTS WITH":
+        return this.testRegex(
+          new RegExp(`^${this.escapeRegex(conditionValue)}`),
+          actualValue
+        );
+      case "ENDS WITH":
+        return this.testRegex(
+          new RegExp(`${this.escapeRegex(conditionValue)}$`),
+          actualValue
+        );
+      case "CONTAINS":
+        return this.testRegex(
+          new RegExp(this.escapeRegex(conditionValue)),
+          actualValue
+        );
+      case "=~":
+        return this.testRegex(new RegExp(conditionValue), actualValue);
+      default:
+        throw new Error(`Unsupported operator: ${condition.operator}`);
+    }
+  }
+  testRegex(regexp, actualValue) {
+    if (actualValue === null || actualValue === void 0) {
+      return false;
+    }
+    if (typeof actualValue !== "string" && typeof actualValue !== "number" && typeof actualValue !== "boolean") {
+      return false;
+    }
+    const regexStr = typeof actualValue === "string" ? actualValue : String(actualValue);
+    try {
+      return regexp.test(regexStr);
+    } catch {
+      return false;
+    }
+  }
+};
+
+// libs/cli/code-graph-core/src/lib/cypher/lib/executor/utils.ts
+var Annonymizer = class {
+  constructor() {
+    this.anonymousVariablePrefix = "annonymous_";
+  }
+  generate(node) {
+    return this.anonymousVariablePrefix + node.id;
+  }
+  isAnonymous(variable) {
+    return variable.startsWith(this.anonymousVariablePrefix);
+  }
+};
+
+// libs/cli/code-graph-core/src/lib/cypher/lib/executor/match-engine.ts
+var MatchEngine = class {
+  constructor(patternMatcher, traverseEngine) {
+    this.patternMatcher = patternMatcher;
+    this.traverseEngine = traverseEngine;
+    this.annonymizer = new Annonymizer();
+  }
+  processMatchStatement(graph, match, existingResults = []) {
+    if (match.patterns.length === 0)
+      return existingResults;
+    const starting = match.patterns[0];
+    const allResults = [];
+    this.patternMatcher.filterMatchingNodes(graph, starting).forEach((node) => {
+      const matches = this.traverseEngine.traverseRelationships(
+        graph,
+        node,
+        starting.variable || this.annonymizer.generate(node),
+        match.patterns.slice(1),
+        match.relationships
+      );
+      allResults.push(...matches);
+    });
+    if (existingResults.length > 0) {
+      if (match.optional) {
+        return this.mergeOptionalResults(existingResults, allResults, match);
+      } else {
+        return this.mergeResults(existingResults, allResults);
+      }
+    }
+    return allResults;
+  }
+  mergeResults(existingResults, newResults) {
+    if (existingResults.length === 0) {
+      return newResults;
+    }
+    const mergedResults = [];
+    for (const existingResult of existingResults) {
+      for (const newResult of newResults) {
+        if (this.canMergeResult(existingResult, newResult)) {
+          mergedResults.push({ ...existingResult, ...newResult });
+        }
+      }
+    }
+    return mergedResults;
+  }
+  /**
+   * Merge optional match results with existing results (left outer join)
+   * - Keeps all existing results
+   * - Merges optional results where variables overlap
+   * - Adds nulls for optional variables when no match is found
+   */
+  mergeOptionalResults(existingResults, optionalResults, match) {
+    if (existingResults.length === 0) {
+      return optionalResults;
+    }
+    const optionalVarNames = /* @__PURE__ */ new Set();
+    for (const pattern of match.patterns) {
+      if (pattern.variable) {
+        optionalVarNames.add(pattern.variable);
+      }
+    }
+    if (match.relationships) {
+      for (const rel of match.relationships) {
+        if (rel.variable) {
+          optionalVarNames.add(rel.variable);
+        }
+      }
+    }
+    if (optionalResults.length === 0) {
+      return existingResults.map((result) => {
+        const resultWithNulls = { ...result };
+        for (const varName of optionalVarNames) {
+          if (!(varName in resultWithNulls)) {
+            resultWithNulls[varName] = null;
+          }
+        }
+        return resultWithNulls;
+      });
+    }
+    for (const optionalResult of optionalResults) {
+      for (const key in optionalResult) {
+        optionalVarNames.add(key);
+      }
+    }
+    const mergedResults = [];
+    for (const existingResult of existingResults) {
+      let hasMatch = false;
+      for (const optionalResult of optionalResults) {
+        if (this.canMergeResult(existingResult, optionalResult)) {
+          mergedResults.push({ ...existingResult, ...optionalResult });
+          hasMatch = true;
+        }
+      }
+      if (!hasMatch) {
+        const resultWithNulls = { ...existingResult };
+        for (const varName of optionalVarNames) {
+          if (!(varName in resultWithNulls)) {
+            resultWithNulls[varName] = null;
+          }
+        }
+        mergedResults.push(resultWithNulls);
+      }
+    }
+    return mergedResults;
+  }
+  /**
+   * Check if additionalResult can be merged with existingResult
+   * Returns true if shared variables match (same node/edge) or if there are no conflicts
+   * Does NOT mutate any parameters
+   */
+  canMergeResult(additionalResult, existingResult) {
+    for (const key in additionalResult) {
+      if (key in existingResult) {
+        const existing = existingResult[key];
+        const additional = additionalResult[key];
+        if (existing !== null && additional !== null) {
+          if ("id" in existing && "id" in additional && existing.id !== additional.id) {
+            return false;
+          }
+        } else if (existing !== additional) {
+          return false;
+        }
+      }
+    }
+    return true;
+  }
+};
+
+// libs/cli/code-graph-core/src/lib/cypher/lib/executor/pattern-matcher.ts
+var PatternMatcher = class {
+  /**
+   * Check if an edge type matches the relationship pattern's edge type(s)
+   * Supports both single edge type (string) and multiple edge types (array)
+   */
+  matchesEdgeType(edgeType, patternEdgeType) {
+    if (!patternEdgeType) {
+      return true;
+    }
+    if (typeof patternEdgeType === "string") {
+      return edgeType === patternEdgeType;
+    }
+    return patternEdgeType.includes(edgeType);
+  }
+  /**
+   * Deep equality check for arrays
+   */
+  arraysEqual(a, b) {
+    if (a.length !== b.length) {
+      return false;
+    }
+    for (let i = 0; i < a.length; i++) {
+      if (Array.isArray(a[i]) && Array.isArray(b[i])) {
+        if (!this.arraysEqual(a[i], b[i])) {
+          return false;
+        }
+      } else if (a[i] !== b[i]) {
+        return false;
+      }
+    }
+    return true;
+  }
+  /**
+   * Check if two values are equal (handles arrays with deep equality)
+   */
+  valuesEqual(expected, actual) {
+    if (Array.isArray(expected) && Array.isArray(actual)) {
+      return this.arraysEqual(expected, actual);
+    }
+    return expected === actual;
+  }
+  /**
+   * Check if a node matches a pattern (labels and properties)
+   */
+  doesNodeMatchPattern(node, pattern) {
+    if (pattern.labels.length > 0) {
+      const labelOperator = pattern.labelOperator || "AND";
+      if (labelOperator === "AND") {
+        if (!pattern.labels.every((label) => node.labels.includes(label))) {
+          return false;
+        }
+      } else {
+        if (!pattern.labels.some((label) => node.labels.includes(label))) {
+          return false;
+        }
+      }
+    }
+    if (pattern.properties) {
+      const notFound = Object.entries(pattern.properties).find(
+        ([key, expectedValue]) => !this.valuesEqual(expectedValue, node[key])
+      ) !== void 0;
+      if (notFound) {
+        return false;
+      }
+    }
+    return true;
+  }
+  findMatchingNodes(graph, pattern) {
+    return Object.values(graph.nodesById).find(
+      (node) => this.doesNodeMatchPattern(node, pattern)
+    );
+  }
+  /**
+   * Match a single node pattern
+   * Finds all nodes in the graph that match the given pattern
+   * Reuses matchesPattern to avoid code duplication
+   */
+  filterMatchingNodes(graph, pattern) {
+    return Object.values(graph.nodesById).filter(
+      (node) => this.doesNodeMatchPattern(node, pattern)
+    );
+  }
+};
+
+// libs/cli/code-graph-core/src/lib/cypher/lib/executor/relationship-navigator.ts
+var RelationshipNavigator = class {
+  constructor(patternMatcher) {
+    this.patternMatcher = patternMatcher;
+  }
+  /**
+   * Find nodes and edges connected via a relationship from the given node
+   * Returns both the connected node and the edge that connects them
+   */
+  findConnectedNodesAndEdges(graph, node, relationship) {
+    const connections = [];
+    const seenNodeIds = /* @__PURE__ */ new Set();
+    if (relationship.direction === "outgoing" || relationship.direction === "both") {
+      const outgoingEdges = graph.edgesBySource[node.id] || [];
+      for (const edge of outgoingEdges) {
+        if (this.patternMatcher.matchesEdgeType(edge.type, relationship.edgeType)) {
+          const targetNode = graph.nodesById[edge.target];
+          if (targetNode && !seenNodeIds.has(targetNode.id)) {
+            seenNodeIds.add(targetNode.id);
+            connections.push({ node: targetNode, edge });
+          }
+        }
+      }
+    }
+    if (relationship.direction === "incoming" || relationship.direction === "both") {
+      const incomingEdges = graph.edgesByTarget[node.id] || [];
+      for (const edge of incomingEdges) {
+        if (this.patternMatcher.matchesEdgeType(edge.type, relationship.edgeType)) {
+          const sourceNode = graph.nodesById[edge.source];
+          if (sourceNode && !seenNodeIds.has(sourceNode.id)) {
+            seenNodeIds.add(sourceNode.id);
+            connections.push({ node: sourceNode, edge });
+          }
+        }
+      }
+    }
+    return connections;
+  }
+};
+
+// libs/cli/code-graph-core/src/lib/cypher/lib/executor/result-formatter.ts
+var ResultFormatter = class {
+  constructor() {
+    this.annonymizer = new Annonymizer();
+  }
+  /**
+   * Format a single match value (node or edge) based on extractData flag
+   */
+  formatValue(value) {
+    if (value === null || value === void 0) {
+      return null;
+    }
+    if ("id" in value && "labels" in value) {
+      const node = value;
+      return node;
+    } else {
+      const edge = value;
+      return edge;
+    }
+  }
+  /**
+   * Sort results based on ORDER BY clause
+   */
+  sortResults(results, orderBy) {
+    return [...results].sort((a, b) => {
+      for (const item of orderBy.items) {
+        const valA = this.getPropertyValue(a[item.variable], item.property);
+        const valB = this.getPropertyValue(b[item.variable], item.property);
+        const comparison = this.compareValues(valA, valB, item.direction);
+        if (comparison !== 0)
+          return comparison;
+      }
+      return 0;
+    });
+  }
+  /**
+   * Get property value from an object, handling nested property access
+   */
+  getPropertyValue(obj, property) {
+    if (obj === null || obj === void 0)
+      return null;
+    return property ? obj[property] : obj;
+  }
+  /**
+   * Compare two values with Neo4j-style NULL handling
+   * ASC: NULLs first, then ascending values
+   * DESC: Values descending, then NULLs last
+   */
+  compareValues(a, b, direction) {
+    const aIsNull = a === null || a === void 0;
+    const bIsNull = b === null || b === void 0;
+    if (aIsNull && bIsNull)
+      return 0;
+    if (aIsNull)
+      return direction === "ASC" ? -1 : 1;
+    if (bIsNull)
+      return direction === "ASC" ? 1 : -1;
+    let result;
+    if (typeof a === "string" && typeof b === "string") {
+      result = a.localeCompare(b);
+    } else {
+      result = a < b ? -1 : a > b ? 1 : 0;
+    }
+    return direction === "DESC" ? -result : result;
+  }
+  /**
+   * Format results with RETURN clause
+   * Only includes variables specified in RETURN clause, with optional aliases
+   * If returnAll is true (RETURN *), returns all variables
+   * If distinct is true, deduplicate results based on returned variables' ids
+   */
+  formatResults(results, returnClause) {
+    let processedResults = returnClause.limit ? results.slice(0, returnClause.limit) : results;
+    if (returnClause.distinct) {
+      processedResults = this.deduplicateResults(processedResults, returnClause);
+    }
+    if (returnClause.returnAll) {
+      return this.formatDefault(processedResults);
+    }
+    return processedResults.map((match) => {
+      const result = {};
+      for (const item of returnClause.items) {
+        const variable = item.expression;
+        if (this.annonymizer.isAnonymous(variable)) {
+          continue;
+        }
+        const alias = item.alias || variable;
+        if (variable in match) {
+          const value = match[variable];
+          result[alias] = this.formatValue(value);
+        } else {
+          throw new Error(`Variable ${variable} not found in match results`);
+        }
+      }
+      return result;
+    });
+  }
+  /**
+   * Deduplicate results based on returned variables' ids
+   */
+  deduplicateResults(results, returnClause) {
+    const seen = /* @__PURE__ */ new Map();
+    for (const match of results) {
+      const key = returnClause.items.map((item) => this.getValueId(match[item.expression])).join("|");
+      if (!seen.has(key)) {
+        seen.set(key, match);
+      }
+    }
+    return Array.from(seen.values());
+  }
+  /**
+   * Get a unique identifier for a match result value
+   */
+  getValueId(value) {
+    if (value === null || value === void 0) {
+      return "null";
+    }
+    if ("id" in value && "labels" in value) {
+      return value.id;
+    }
+    const edge = value;
+    return `edge:${edge.source}|${edge.target}|${edge.type}`;
+  }
+  /**
+   * Format results without RETURN clause (default)
+   * Returns all matched variables keyed by their variable names
+   */
+  formatDefault(matches) {
+    return matches.map((match) => {
+      const result = {};
+      for (const [varName, value] of Object.entries(match)) {
+        if (this.annonymizer.isAnonymous(varName)) {
+          continue;
+        }
+        result[varName] = this.formatValue(value);
+      }
+      return result;
+    });
+  }
+};
+
+// libs/cli/code-graph-core/src/lib/cypher/lib/executor/traverse-engine.ts
+var TraverseEngine = class {
+  constructor(patternMatcher, relationshipNavigator) {
+    this.patternMatcher = patternMatcher;
+    this.relationshipNavigator = relationshipNavigator;
+    this.annonymizer = new Annonymizer();
+  }
+  /**
+   * Recursively traverse relationships to match subsequent patterns
+   * Supports returning edges as variables when relationship variable is specified
+   */
+  traverseRelationships(graph, currentNode, currentVarName, remainingPatterns, relationships) {
+    if (remainingPatterns.length === 0) {
+      return [{ [currentVarName]: currentNode }];
+    }
+    const results = [];
+    const nextPattern = remainingPatterns[0];
+    const nextRelationship = relationships[0];
+    const nextVarName = nextPattern.variable || this.annonymizer.generate(currentNode);
+    const remainingPatterns_ = remainingPatterns.slice(1);
+    const remainingRelationships = relationships.slice(1);
+    if (nextRelationship.variableLength) {
+      return this.traverseVariableLengthPath(
+        graph,
+        currentNode,
+        currentVarName,
+        nextRelationship,
+        nextPattern,
+        nextVarName,
+        remainingPatterns_,
+        remainingRelationships
+      );
+    }
+    const connections = this.relationshipNavigator.findConnectedNodesAndEdges(
+      graph,
+      currentNode,
+      nextRelationship
+    );
+    for (const { node: connectedNode, edge } of connections) {
+      if (this.patternMatcher.doesNodeMatchPattern(connectedNode, nextPattern)) {
+        const subMatches = this.traverseRelationships(
+          graph,
+          connectedNode,
+          nextVarName,
+          remainingPatterns_,
+          remainingRelationships
+        );
+        for (const subMatch of subMatches) {
+          const result = {
+            [currentVarName]: currentNode,
+            [nextVarName]: connectedNode,
+            // Always include the connected node
+            ...subMatch
+          };
+          if (nextRelationship.variable && edge) {
+            result[nextRelationship.variable] = edge;
+          }
+          results.push(result);
+        }
+      }
+    }
+    return results;
+  }
+  /**
+   * Traverse variable-length paths (zero or more edges)
+   * Handles cycles by tracking visited nodes
+   */
+  traverseVariableLengthPath(graph, startNode, startVarName, relationship, targetPattern, targetVarName, remainingPatterns, remainingRelationships) {
+    const results = [];
+    const minLength = relationship.minLength ?? 0;
+    const maxLength = relationship.maxLength ?? Infinity;
+    const traverse = (currentNode, pathLength, visited, pathEdges) => {
+      if (pathLength >= minLength && this.patternMatcher.doesNodeMatchPattern(currentNode, targetPattern)) {
+        const subMatches = this.traverseRelationships(
+          graph,
+          currentNode,
+          targetVarName,
+          remainingPatterns,
+          remainingRelationships
+        );
+        for (const subMatch of subMatches) {
+          const result = {
+            [startVarName]: startNode,
+            [targetVarName]: currentNode,
+            ...subMatch
+          };
+          if (relationship.variable && pathEdges.length > 0) {
+            result[relationship.variable] = pathEdges[pathEdges.length - 1];
+          }
+          results.push(result);
+        }
+      }
+      if (pathLength < maxLength) {
+        const connections2 = this.relationshipNavigator.findConnectedNodesAndEdges(
+          graph,
+          currentNode,
+          relationship
+        );
+        for (const { node: nextNode, edge } of connections2) {
+          if (!visited.has(nextNode.id)) {
+            const newVisited = new Set(visited);
+            newVisited.add(nextNode.id);
+            traverse(nextNode, pathLength + 1, newVisited, [
+              ...pathEdges,
+              edge
+            ]);
+          }
+        }
+      }
+    };
+    if (minLength === 0 && this.patternMatcher.doesNodeMatchPattern(startNode, targetPattern)) {
+      const subMatches = this.traverseRelationships(
+        graph,
+        startNode,
+        targetVarName,
+        remainingPatterns,
+        remainingRelationships
+      );
+      for (const subMatch of subMatches) {
+        const result = {
+          [startVarName]: startNode,
+          [targetVarName]: startNode,
+          ...subMatch
+        };
+        results.push(result);
+      }
+    }
+    const connections = this.relationshipNavigator.findConnectedNodesAndEdges(
+      graph,
+      startNode,
+      relationship
+    );
+    for (const { node: nextNode, edge } of connections) {
+      traverse(nextNode, 1, /* @__PURE__ */ new Set([startNode.id, nextNode.id]), [edge]);
+    }
+    return results;
+  }
+};
+
+// libs/cli/code-graph-core/src/lib/cypher/lib/executor/executor.ts
+var CypherExecutor = class {
+  constructor(graph) {
+    this.graph = graph;
+    this.conditionEvaluator = new ConditionEvaluator();
+    const patternMatcher = new PatternMatcher();
+    const relationshipNavigator = new RelationshipNavigator(patternMatcher);
+    const traverseEngine = new TraverseEngine(
+      patternMatcher,
+      relationshipNavigator
+    );
+    this.matchEngine = new MatchEngine(patternMatcher, traverseEngine);
+    this.resultFormatter = new ResultFormatter();
+  }
+  /**
+   * Execute a parsed Cypher query
+   * @param extractData - If true (default), returns node.data. If false, returns full GraphNode objects.
+   * For edges, always returns the full GraphEdge object (edges have no data property).
+   * Returns results where keys are variable names and values are either node data or edge objects
+   */
+  execute(query2) {
+    if (query2.statements.length === 0) {
+      throw new Error("Query must have at least one statement");
+    }
+    if (query2.statements[query2.statements.length - 1].type !== "ReturnStatement") {
+      throw new Error("MATCH Query must have a RETURN statement");
+    }
+    let results = [];
+    for (const statement of query2.statements) {
+      if (statement.type === "MatchStatement") {
+        results = this.matchEngine.processMatchStatement(
+          this.graph,
+          statement,
+          results
+        );
+      } else if (statement.type === "WhereStatement") {
+        results = this.conditionEvaluator.applyWhereClauseIfNeeded(
+          results,
+          statement
+        );
+      } else if (statement.type === "OrderByStatement") {
+        results = this.resultFormatter.sortResults(results, statement);
+      }
+    }
+    const returnStatement = query2.statements[query2.statements.length - 1];
+    let formattedResults = this.resultFormatter.formatResults(
+      results,
+      returnStatement
+    );
+    return formattedResults;
+  }
+};
+
+// libs/cli/code-graph-core/src/lib/cypher/lib/lexer.ts
+var Lexer = class {
+  constructor(input) {
+    this.input = input;
+    this.position = 0;
+    this.currentChar = input.length > 0 ? input[0] : null;
+  }
+  advance() {
+    this.position++;
+    this.currentChar = this.position >= this.input.length ? null : this.input[this.position];
+  }
+  skipWhitespace() {
+    while (this.currentChar && /\s/.test(this.currentChar)) {
+      this.advance();
+    }
+  }
+  readIdentifier() {
+    let result = "";
+    while (this.currentChar && /[a-zA-Z0-9_]/.test(this.currentChar)) {
+      result += this.currentChar;
+      this.advance();
+    }
+    return result;
+  }
+  readString() {
+    const quote = this.currentChar;
+    this.advance();
+    let result = "";
+    while (this.currentChar && this.currentChar !== quote) {
+      if (this.currentChar === "\\") {
+        this.advance();
+        if (this.currentChar === "n") {
+          result += "\n";
+        } else if (this.currentChar === "t") {
+          result += "	";
+        } else {
+          result += this.currentChar;
+        }
+        this.advance();
+      } else {
+        result += this.currentChar;
+        this.advance();
+      }
+    }
+    if (this.currentChar === quote) {
+      this.advance();
+    }
+    return result;
+  }
+  readNumber() {
+    let result = "";
+    while (this.currentChar && /[0-9.]/.test(this.currentChar)) {
+      result += this.currentChar;
+      this.advance();
+    }
+    return result;
+  }
+  peekKeyword() {
+    const savedPos = this.position;
+    const savedChar = this.currentChar;
+    const keyword = this.readIdentifier();
+    this.position = savedPos;
+    this.currentChar = savedChar;
+    return keyword.length > 0 ? keyword.toUpperCase() : null;
+  }
+  tokenize() {
+    const tokens = [];
+    this.position = 0;
+    this.currentChar = this.input.length > 0 ? this.input[0] : null;
+    while (this.currentChar !== null) {
+      this.skipWhitespace();
+      if (!this.currentChar)
+        break;
+      const startPos = this.position;
+      const keyword = this.peekKeyword();
+      const keywordMap = {
+        MATCH: "MATCH" /* MATCH */,
+        OPTIONAL: "OPTIONAL" /* OPTIONAL */,
+        RETURN: "RETURN" /* RETURN */,
+        DISTINCT: "DISTINCT" /* DISTINCT */,
+        WHERE: "WHERE" /* WHERE */,
+        AND: "AND" /* AND */,
+        OR: "OR" /* OR */,
+        AS: "AS" /* AS */,
+        IN: "IN" /* IN */,
+        NOT: "NOT" /* NOT */,
+        IS: "IS" /* IS */,
+        NULL: "NULL" /* NULL */,
+        TRUE: "TRUE" /* TRUE */,
+        FALSE: "FALSE" /* FALSE */,
+        STARTS: "STARTS" /* STARTS */,
+        ENDS: "ENDS" /* ENDS */,
+        CONTAINS: "CONTAINS" /* CONTAINS */,
+        WITH: "WITH" /* WITH */,
+        LIMIT: "LIMIT" /* LIMIT */,
+        ORDER: "ORDER" /* ORDER */,
+        BY: "BY" /* BY */,
+        ASC: "ASC" /* ASC */,
+        DESC: "DESC" /* DESC */
+      };
+      if (keyword && keywordMap[keyword]) {
+        tokens.push({
+          type: keywordMap[keyword],
+          value: keyword,
+          position: startPos
+        });
+        this.readIdentifier();
+        continue;
+      }
+      switch (this.currentChar) {
+        case "(":
+          tokens.push({
+            type: "LPAREN" /* LPAREN */,
+            value: "(",
+            position: startPos
+          });
+          this.advance();
+          break;
+        case ")":
+          tokens.push({
+            type: "RPAREN" /* RPAREN */,
+            value: ")",
+            position: startPos
+          });
+          this.advance();
+          break;
+        case "[":
+          tokens.push({
+            type: "LBRACKET" /* LBRACKET */,
+            value: "[",
+            position: startPos
+          });
+          this.advance();
+          break;
+        case "]":
+          tokens.push({
+            type: "RBRACKET" /* RBRACKET */,
+            value: "]",
+            position: startPos
+          });
+          this.advance();
+          break;
+        case "{":
+          tokens.push({
+            type: "LBRACE" /* LBRACE */,
+            value: "{",
+            position: startPos
+          });
+          this.advance();
+          break;
+        case "}":
+          tokens.push({
+            type: "RBRACE" /* RBRACE */,
+            value: "}",
+            position: startPos
+          });
+          this.advance();
+          break;
+        case "<":
+          if (this.position + 1 < this.input.length && this.input[this.position + 1] === "-") {
+            tokens.push({
+              type: "ARROW" /* ARROW */,
+              value: "<-",
+              position: startPos
+            });
+            this.advance();
+            this.advance();
+          } else if (this.position + 1 < this.input.length && this.input[this.position + 1] === "=") {
+            tokens.push({
+              type: "LTE" /* LTE */,
+              value: "<=",
+              position: startPos
+            });
+            this.advance();
+            this.advance();
+          } else {
+            tokens.push({
+              type: "LT" /* LT */,
+              value: "<",
+              position: startPos
+            });
+            this.advance();
+          }
+          break;
+        case "-":
+          if (this.position + 1 < this.input.length && this.input[this.position + 1] === ">") {
+            tokens.push({
+              type: "ARROW" /* ARROW */,
+              value: "->",
+              position: startPos
+            });
+            this.advance();
+            this.advance();
+          } else {
+            tokens.push({
+              type: "DASH" /* DASH */,
+              value: "-",
+              position: startPos
+            });
+            this.advance();
+          }
+          break;
+        case "=":
+          if (this.position + 1 < this.input.length && this.input[this.position + 1] === "~") {
+            tokens.push({
+              type: "REGEX_MATCH" /* REGEX_MATCH */,
+              value: "=~",
+              position: startPos
+            });
+            this.advance();
+            this.advance();
+          } else {
+            tokens.push({
+              type: "EQUALS" /* EQUALS */,
+              value: "=",
+              position: startPos
+            });
+            this.advance();
+          }
+          break;
+        case "!":
+          if (this.position + 1 < this.input.length && this.input[this.position + 1] === "=") {
+            tokens.push({
+              type: "NOT_EQUALS" /* NOT_EQUALS */,
+              value: "!=",
+              position: startPos
+            });
+            this.advance();
+            this.advance();
+          } else {
+            throw new Error(`Unexpected character: ! at position ${startPos}`);
+          }
+          break;
+        case ">":
+          if (this.position + 1 < this.input.length && this.input[this.position + 1] === "=") {
+            tokens.push({
+              type: "GTE" /* GTE */,
+              value: ">=",
+              position: startPos
+            });
+            this.advance();
+            this.advance();
+          } else {
+            tokens.push({
+              type: "GT" /* GT */,
+              value: ">",
+              position: startPos
+            });
+            this.advance();
+          }
+          break;
+        case ",":
+          tokens.push({
+            type: "COMMA" /* COMMA */,
+            value: ",",
+            position: startPos
+          });
+          this.advance();
+          break;
+        case ".":
+          tokens.push({
+            type: "DOT" /* DOT */,
+            value: ".",
+            position: startPos
+          });
+          this.advance();
+          break;
+        case "|":
+          tokens.push({
+            type: "PIPE" /* PIPE */,
+            value: "|",
+            position: startPos
+          });
+          this.advance();
+          break;
+        case "*":
+          tokens.push({
+            type: "ASTERISK" /* ASTERISK */,
+            value: "*",
+            position: startPos
+          });
+          this.advance();
+          break;
+        case ":":
+          tokens.push({
+            type: "LABEL" /* LABEL */,
+            value: ":",
+            position: startPos
+          });
+          this.advance();
+          break;
+        case '"':
+        case "'":
+          tokens.push({
+            type: "STRING" /* STRING */,
+            value: this.readString(),
+            position: startPos
+          });
+          break;
+        default:
+          if (/[0-9]/.test(this.currentChar)) {
+            tokens.push({
+              type: "NUMBER" /* NUMBER */,
+              value: this.readNumber(),
+              position: startPos
+            });
+          } else if (/[a-zA-Z_]/.test(this.currentChar)) {
+            tokens.push({
+              type: "IDENTIFIER" /* IDENTIFIER */,
+              value: this.readIdentifier(),
+              position: startPos
+            });
+          } else {
+            throw new Error(
+              `Unexpected character: ${this.currentChar} at position ${startPos}`
+            );
+          }
+      }
+    }
+    tokens.push({ type: "EOF" /* EOF */, value: "", position: this.position });
+    return tokens;
+  }
+};
+
+// libs/cli/code-graph-core/src/lib/cypher/lib/parser.ts
+var Parser = class {
+  constructor(tokens) {
+    this.tokens = [];
+    this.position = 0;
+    this.tokens = tokens;
+  }
+  current() {
+    return this.tokens[this.position];
+  }
+  advance() {
+    const token = this.current();
+    if (this.position < this.tokens.length - 1) {
+      this.position++;
+    }
+    return token;
+  }
+  peek() {
+    return this.tokens[this.position + 1] || this.tokens[this.tokens.length - 1];
+  }
+  expect(type) {
+    const token = this.current();
+    if (token.type !== type) {
+      throw new Error(
+        `Expected ${type}, got ${token.type} at position ${token.position}`
+      );
+    }
+    return this.advance();
+  }
+  isKeyword(keyword) {
+    return this.current().type === keyword;
+  }
+  /**
+   * Parse a property object: { key: value, ... }
+   * Note: Cypher uses colon (:) for properties in node patterns, not equals (=)
+   */
+  parseProperties() {
+    this.expect("LBRACE" /* LBRACE */);
+    const properties = {};
+    if (this.current().type === "RBRACE" /* RBRACE */) {
+      this.advance();
+      return properties;
+    }
+    while (true) {
+      const key = this.expect("IDENTIFIER" /* IDENTIFIER */).value;
+      this.expect("LABEL" /* LABEL */);
+      let value;
+      if (this.current().type === "LBRACKET" /* LBRACKET */) {
+        value = this.parseArrayLiteral();
+      } else if (this.current().type === "STRING" /* STRING */) {
+        value = this.advance().value;
+      } else if (this.current().type === "NUMBER" /* NUMBER */) {
+        value = parseFloat(this.advance().value);
+      } else if (this.current().type === "TRUE" /* TRUE */) {
+        value = true;
+        this.advance();
+      } else if (this.current().type === "FALSE" /* FALSE */) {
+        value = false;
+        this.advance();
+      } else if (this.current().type === "IDENTIFIER" /* IDENTIFIER */) {
+        value = this.advance().value;
+      } else {
+        throw new Error(
+          `Unexpected token type for property value: ${this.current().type}`
+        );
+      }
+      properties[key] = value;
+      if (this.current().type === "RBRACE" /* RBRACE */) {
+        this.advance();
+        break;
+      }
+      this.expect("COMMA" /* COMMA */);
+    }
+    return properties;
+  }
+  /**
+   * Parse a node pattern: (var:Label {prop: value}) or (:Label {prop: value})
+   */
+  parseNodePattern() {
+    this.expect("LPAREN" /* LPAREN */);
+    const pattern = {
+      type: "NodePattern",
+      labels: []
+    };
+    if (this.current().type === "IDENTIFIER" /* IDENTIFIER */) {
+      const nextToken = this.peek();
+      if (nextToken.type === "LABEL" /* LABEL */ || nextToken.type === "LBRACE" /* LBRACE */ || nextToken.type === "RPAREN" /* RPAREN */) {
+        pattern.variable = this.advance().value;
+      }
+    }
+    if (this.current().type === "LABEL" /* LABEL */) {
+      this.advance();
+      if (this.current().type !== "IDENTIFIER" /* IDENTIFIER */) {
+        throw new Error(
+          `Expected identifier after :, got ${this.current().type}`
+        );
+      }
+      pattern.labels.push(this.advance().value);
+      if (this.current().type === "LABEL" /* LABEL */) {
+        pattern.labelOperator = "AND";
+        while (this.current().type === "LABEL" /* LABEL */) {
+          this.advance();
+          if (this.current().type === "IDENTIFIER" /* IDENTIFIER */) {
+            pattern.labels.push(this.advance().value);
+          } else {
+            throw new Error(
+              `Expected identifier after :, got ${this.current().type}`
+            );
+          }
+        }
+      } else if (this.current().type === "PIPE" /* PIPE */) {
+        pattern.labelOperator = "OR";
+        while (this.current().type === "PIPE" /* PIPE */) {
+          this.advance();
+          if (this.current().type === "IDENTIFIER" /* IDENTIFIER */) {
+            pattern.labels.push(this.advance().value);
+          } else {
+            throw new Error(
+              `Expected identifier after |, got ${this.current().type}`
+            );
+          }
+        }
+      } else {
+        pattern.labelOperator = "AND";
+      }
+    }
+    if (this.current().type === "LBRACE" /* LBRACE */) {
+      pattern.properties = this.parseProperties();
+    }
+    this.expect("RPAREN" /* RPAREN */);
+    return pattern;
+  }
+  /**
+   * Parse relationship pattern: -[:RELATIONSHIP_TYPE]-> or <-[:RELATIONSHIP_TYPE]- or -[r:RELATIONSHIP_TYPE]->
+   */
+  parseRelationship() {
+    const relationship = {
+      type: "RelationshipPattern",
+      direction: "outgoing"
+    };
+    if (this.current().type === "ARROW" /* ARROW */ && this.current().value === "<-") {
+      relationship.direction = "incoming";
+      this.advance();
+    } else {
+      this.expect("DASH" /* DASH */);
+    }
+    if (this.current().type === "LBRACKET" /* LBRACKET */) {
+      this.advance();
+      if (this.current().type === "IDENTIFIER" /* IDENTIFIER */) {
+        const nextToken = this.peek();
+        if (nextToken.type === "LABEL" /* LABEL */ || nextToken.type === "ASTERISK" /* ASTERISK */) {
+          relationship.variable = this.advance().value;
+        }
+      }
+      if (this.current().type === "ASTERISK" /* ASTERISK */) {
+        this.advance();
+        relationship.variableLength = true;
+        relationship.minLength = 0;
+        relationship.maxLength = void 0;
+      } else if (this.current().type === "LABEL" /* LABEL */) {
+        this.advance();
+        const edgeTypes = [];
+        edgeTypes.push(this.expect("IDENTIFIER" /* IDENTIFIER */).value);
+        while (this.current().type === "PIPE" /* PIPE */) {
+          this.advance();
+          edgeTypes.push(this.expect("IDENTIFIER" /* IDENTIFIER */).value);
+        }
+        relationship.edgeType = edgeTypes.length === 1 ? edgeTypes[0] : edgeTypes;
+        if (this.current().type === "ASTERISK" /* ASTERISK */) {
+          this.advance();
+          relationship.variableLength = true;
+          relationship.minLength = 0;
+          relationship.maxLength = void 0;
+        }
+      }
+      this.expect("RBRACKET" /* RBRACKET */);
+    }
+    if (relationship.direction === "incoming") {
+      this.expect("DASH" /* DASH */);
+    } else {
+      if (this.current().type === "ARROW" /* ARROW */ && this.current().value === "->") {
+        this.advance();
+      } else if (this.current().type === "DASH" /* DASH */) {
+        relationship.direction = "both";
+        this.advance();
+      }
+    }
+    return relationship;
+  }
+  /**
+   * Parse MATCH clause (supports OPTIONAL MATCH)
+   */
+  parseMatch() {
+    const isOptional = this.isKeyword("OPTIONAL" /* OPTIONAL */);
+    if (isOptional) {
+      this.advance();
+    }
+    this.expect("MATCH" /* MATCH */);
+    const firstPattern = this.parsePatternChain();
+    const matchClause = {
+      type: "MatchClause",
+      patterns: firstPattern.patterns,
+      relationships: firstPattern.relationships,
+      additionalMatches: []
+    };
+    while (this.current().type === "COMMA" /* COMMA */) {
+      this.advance();
+      const additionalPattern = this.parsePatternChain();
+      matchClause.additionalMatches.push(additionalPattern);
+    }
+    if (isOptional) {
+      matchClause.optionalMatches = [
+        {
+          type: "MatchStatement",
+          patterns: firstPattern.patterns,
+          relationships: firstPattern.relationships
+        },
+        ...matchClause.additionalMatches || []
+      ];
+      matchClause.patterns = [];
+      matchClause.relationships = void 0;
+      matchClause.additionalMatches = void 0;
+    }
+    return matchClause;
+  }
+  /**
+   * Parse a pattern chain: (node)-[:rel]->(node)-[:rel]->(node)...
+   * Returns patterns and relationships for a single connected pattern
+   */
+  parsePatternChain() {
+    const patterns = [];
+    const relationships = [];
+    patterns.push(this.parseNodePattern());
+    while (this.current().type === "DASH" /* DASH */ || this.current().type === "ARROW" /* ARROW */) {
+      relationships.push(this.parseRelationship());
+      patterns.push(this.parseNodePattern());
+    }
+    return {
+      type: "MatchStatement",
+      patterns,
+      relationships: relationships.length > 0 ? relationships : void 0
+    };
+  }
+  /**
+   * Parse WHERE clause
+   * Example: WHERE m.type = "Command" AND "param" IN m.parameters
+   * Note: Flat properties only (no nesting, like Neo4j Cypher)
+   */
+  parseWhere() {
+    this.expect("WHERE" /* WHERE */);
+    const conditions = [];
+    let logic;
+    while (true) {
+      const variable = this.expect("IDENTIFIER" /* IDENTIFIER */).value;
+      let property;
+      if (this.current().type === "DOT" /* DOT */) {
+        this.advance();
+        property = this.expect("IDENTIFIER" /* IDENTIFIER */).value;
+      }
+      let operator = "=";
+      if (this.current().type === "EQUALS" /* EQUALS */) {
+        operator = "=";
+        this.advance();
+      } else if (this.current().type === "NOT_EQUALS" /* NOT_EQUALS */) {
+        operator = "!=";
+        this.advance();
+      } else if (this.current().type === "GT" /* GT */) {
+        operator = ">";
+        this.advance();
+      } else if (this.current().type === "LT" /* LT */) {
+        operator = "<";
+        this.advance();
+      } else if (this.current().type === "GTE" /* GTE */) {
+        operator = ">=";
+        this.advance();
+      } else if (this.current().type === "LTE" /* LTE */) {
+        operator = "<=";
+        this.advance();
+      } else if (this.current().type === "NOT" /* NOT */) {
+        this.advance();
+        this.expect("IN" /* IN */);
+        operator = "NOT IN";
+      } else if (this.current().type === "IN" /* IN */) {
+        this.advance();
+        operator = "IN";
+      } else if (this.current().type === "IS" /* IS */) {
+        this.advance();
+        if (this.isKeyword("NULL" /* NULL */)) {
+          this.advance();
+          operator = "IS NULL";
+        } else if (this.isKeyword("NOT" /* NOT */)) {
+          this.advance();
+          this.expect("NULL" /* NULL */);
+          operator = "IS NOT NULL";
+        } else {
+          throw new Error(
+            `Expected NULL or NOT NULL after IS at position ${this.current().position}`
+          );
+        }
+      } else if (this.current().type === "STARTS" /* STARTS */) {
+        this.advance();
+        this.expect("WITH" /* WITH */);
+        operator = "STARTS WITH";
+      } else if (this.current().type === "ENDS" /* ENDS */) {
+        this.advance();
+        this.expect("WITH" /* WITH */);
+        operator = "ENDS WITH";
+      } else if (this.current().type === "CONTAINS" /* CONTAINS */) {
+        operator = "CONTAINS";
+        this.advance();
+      } else if (this.current().type === "REGEX_MATCH" /* REGEX_MATCH */) {
+        operator = "=~";
+        this.advance();
+      } else {
+        throw new Error(
+          `Unsupported operator at position ${this.current().position}.`
+        );
+      }
+      let value = null;
+      if (operator === "IS NULL" || operator === "IS NOT NULL") {
+      } else if (operator === "STARTS WITH" || operator === "ENDS WITH" || operator === "CONTAINS" || operator === "=~") {
+        if (this.current().type === "STRING" /* STRING */) {
+          value = this.advance().value;
+        } else {
+          throw new Error(
+            `String matching operators (${operator}) require a string value at position ${this.current().position}`
+          );
+        }
+      } else if (this.current().type === "LBRACKET" /* LBRACKET */) {
+        value = this.parseArrayLiteral();
+      } else if (this.current().type === "STRING" /* STRING */) {
+        value = this.advance().value;
+      } else if (this.current().type === "NUMBER" /* NUMBER */) {
+        value = parseFloat(this.advance().value);
+      } else if (this.current().type === "TRUE" /* TRUE */) {
+        value = true;
+        this.advance();
+      } else if (this.current().type === "FALSE" /* FALSE */) {
+        value = false;
+        this.advance();
+      } else if (this.current().type === "IDENTIFIER" /* IDENTIFIER */) {
+        value = this.advance().value;
+      } else {
+        throw new Error(
+          `Unexpected token type for WHERE value: ${this.current().type}`
+        );
+      }
+      conditions.push({ variable, property, operator, value });
+      if (this.isKeyword("AND" /* AND */)) {
+        if (logic === void 0) {
+          logic = "AND";
+        } else if (logic !== "AND") {
+          throw new Error("Cannot mix AND and OR in WHERE clause");
+        }
+        this.advance();
+        continue;
+      } else if (this.isKeyword("OR" /* OR */)) {
+        if (logic === void 0) {
+          logic = "OR";
+        } else if (logic !== "OR") {
+          throw new Error("Cannot mix AND and OR in WHERE clause");
+        }
+        this.advance();
+        continue;
+      }
+      break;
+    }
+    return {
+      type: "WhereClause",
+      conditions,
+      logic
+    };
+  }
+  /**
+   * Parse array literal: [value1, value2, ...]
+   */
+  parseArrayLiteral() {
+    this.expect("LBRACKET" /* LBRACKET */);
+    const array = [];
+    if (this.current().type === "RBRACKET" /* RBRACKET */) {
+      this.advance();
+      return array;
+    }
+    while (true) {
+      if (this.current().type === "STRING" /* STRING */) {
+        array.push(this.advance().value);
+      } else if (this.current().type === "NUMBER" /* NUMBER */) {
+        array.push(parseFloat(this.advance().value));
+      } else if (this.current().type === "TRUE" /* TRUE */) {
+        array.push(true);
+        this.advance();
+      } else if (this.current().type === "FALSE" /* FALSE */) {
+        array.push(false);
+        this.advance();
+      } else if (this.current().type === "IDENTIFIER" /* IDENTIFIER */) {
+        array.push(this.advance().value);
+      } else {
+        throw new Error(
+          `Unexpected token type in array literal: ${this.current().type}`
+        );
+      }
+      if (this.current().type === "COMMA" /* COMMA */) {
+        this.advance();
+      } else if (this.current().type === "RBRACKET" /* RBRACKET */) {
+        this.advance();
+        break;
+      } else {
+        throw new Error(
+          `Expected comma or closing bracket in array literal at position ${this.current().position}`
+        );
+      }
+    }
+    return array;
+  }
+  /**
+   * Parse RETURN clause
+   * Supports: RETURN *, RETURN DISTINCT, RETURN var1, var2, RETURN var AS alias, LIMIT n
+   */
+  parseReturn() {
+    this.expect("RETURN" /* RETURN */);
+    const distinct = this.isKeyword("DISTINCT" /* DISTINCT */);
+    if (distinct) {
+      this.advance();
+    }
+    if (this.current().type === "ASTERISK" /* ASTERISK */) {
+      this.advance();
+      const limit2 = this.parseOptionalLimit();
+      return {
+        type: "ReturnClause",
+        distinct,
+        returnAll: true,
+        items: [],
+        limit: limit2
+      };
+    }
+    const items = [];
+    while (true) {
+      const expression = this.expect("IDENTIFIER" /* IDENTIFIER */).value;
+      let alias;
+      if (this.isKeyword("AS" /* AS */)) {
+        this.advance();
+        alias = this.expect("IDENTIFIER" /* IDENTIFIER */).value;
+      }
+      items.push({ expression, alias });
+      if (this.current().type === "COMMA" /* COMMA */) {
+        this.advance();
+        continue;
+      }
+      break;
+    }
+    const limit = this.parseOptionalLimit();
+    return {
+      type: "ReturnClause",
+      distinct,
+      returnAll: false,
+      items,
+      limit
+    };
+  }
+  /**
+   * Parse optional LIMIT clause
+   * Returns the limit number or undefined if not present
+   */
+  parseOptionalLimit() {
+    if (this.isKeyword("LIMIT" /* LIMIT */)) {
+      this.advance();
+      const limitToken = this.expect("NUMBER" /* NUMBER */);
+      return parseInt(limitToken.value, 10);
+    }
+    return void 0;
+  }
+  /**
+   * Parse ORDER BY clause
+   * Supports: ORDER BY n.name, ORDER BY n.name ASC, ORDER BY n.name DESC
+   * Also supports multiple fields: ORDER BY n.type DESC, n.name ASC
+   */
+  parseOrderBy() {
+    this.expect("ORDER" /* ORDER */);
+    this.expect("BY" /* BY */);
+    const items = [];
+    while (true) {
+      const variable = this.expect("IDENTIFIER" /* IDENTIFIER */).value;
+      let property;
+      if (this.current().type === "DOT" /* DOT */) {
+        this.advance();
+        property = this.expect("IDENTIFIER" /* IDENTIFIER */).value;
+      }
+      let direction = "ASC";
+      if (this.isKeyword("ASC" /* ASC */)) {
+        this.advance();
+        direction = "ASC";
+      } else if (this.isKeyword("DESC" /* DESC */)) {
+        this.advance();
+        direction = "DESC";
+      }
+      items.push({ variable, property, direction });
+      if (this.current().type === "COMMA" /* COMMA */) {
+        this.advance();
+        continue;
+      }
+      break;
+    }
+    return { type: "OrderByStatement", items };
+  }
+  /**
+   * Parse entire Cypher query
+   * Returns statements in execution order
+   */
+  parse() {
+    const statements = [];
+    while (this.current().type !== "EOF" /* EOF */) {
+      if (this.isKeyword("MATCH" /* MATCH */) || this.isKeyword("OPTIONAL" /* OPTIONAL */)) {
+        const isOptional = this.isKeyword("OPTIONAL" /* OPTIONAL */);
+        const matchClause = this.parseMatch();
+        if (matchClause.optionalMatches) {
+          for (const optionalMatch of matchClause.optionalMatches) {
+            statements.push({
+              type: "MatchStatement",
+              patterns: optionalMatch.patterns,
+              relationships: optionalMatch.relationships,
+              optional: true
+            });
+          }
+        } else {
+          if (matchClause.patterns.length > 0) {
+            statements.push({
+              type: "MatchStatement",
+              patterns: matchClause.patterns,
+              relationships: matchClause.relationships,
+              optional: false
+            });
+          }
+          if (matchClause.additionalMatches) {
+            for (const additionalMatch of matchClause.additionalMatches) {
+              statements.push({
+                type: "MatchStatement",
+                patterns: additionalMatch.patterns,
+                relationships: additionalMatch.relationships,
+                optional: false
+              });
+            }
+          }
+        }
+        continue;
+      }
+      if (this.isKeyword("WHERE" /* WHERE */)) {
+        const whereClause = this.parseWhere();
+        statements.push({
+          type: "WhereStatement",
+          conditions: whereClause.conditions,
+          logic: whereClause.logic
+        });
+        continue;
+      }
+      if (this.isKeyword("ORDER" /* ORDER */)) {
+        const orderByStatement = this.parseOrderBy();
+        statements.push(orderByStatement);
+        continue;
+      }
+      if (this.isKeyword("RETURN" /* RETURN */)) {
+        const returnClause = this.parseReturn();
+        statements.push({
+          type: "ReturnStatement",
+          distinct: returnClause.distinct,
+          returnAll: returnClause.returnAll,
+          items: returnClause.items,
+          limit: returnClause.limit
+        });
+        continue;
+      }
+      break;
+    }
+    if (this.current().type !== "EOF" /* EOF */) {
+      throw new Error(
+        `Unexpected token: ${this.current().type} at position ${this.current().position}`
+      );
+    }
+    return {
+      type: "CypherQuery",
+      statements
+    };
+  }
+};
+
+// libs/cli/code-graph-core/src/lib/cypher/lib/validator/unsupported-features.config.ts
+var FORBIDDEN_KEYWORDS = [
+  {
+    pattern: /\bWITH\b/i,
+    name: "WITH clause",
+    errorMessage: "WITH clause is not supported. Cannot use WITH for intermediate results or variable passing.",
+    alternative: "Use multiple MATCH statements or inline variables directly in WHERE/RETURN clauses."
+  },
+  {
+    pattern: /\bUNWIND\b/i,
+    name: "UNWIND clause",
+    errorMessage: "UNWIND clause is not supported. Cannot use UNWIND to expand arrays."
+  },
+  {
+    pattern: /\bUNION\b/i,
+    name: "UNION clause",
+    errorMessage: "UNION clause is not supported. Cannot combine result sets with UNION."
+  },
+  {
+    pattern: /\bCREATE\b/i,
+    name: "CREATE clause",
+    errorMessage: "CREATE clause is not supported. This is a read-only query engine (no mutations)."
+  },
+  {
+    pattern: /\bMERGE\b/i,
+    name: "MERGE clause",
+    errorMessage: "MERGE clause is not supported. This is a read-only query engine (no mutations)."
+  },
+  {
+    pattern: /\bDELETE\b/i,
+    name: "DELETE clause",
+    errorMessage: "DELETE clause is not supported. This is a read-only query engine (no mutations)."
+  }
+  // {
+  //   pattern: /\bSET\b/i,
+  //   name: 'SET clause',
+  //   errorMessage:
+  //     'SET clause is not supported. This is a read-only query engine (no mutations).',
+  // },
+];
+var FORBIDDEN_AGGREGATIONS = [
+  {
+    pattern: /\bCOUNT\s*\(/i,
+    name: "COUNT() function",
+    errorMessage: "COUNT() aggregation function is not supported. Aggregation functions are not available.",
+    alternative: "Use manual counting patterns or return all results and count in application code."
+  },
+  {
+    pattern: /\bSUM\s*\(/i,
+    name: "SUM() function",
+    errorMessage: "SUM() aggregation function is not supported. Aggregation functions are not available."
+  },
+  {
+    pattern: /\bcollect\s*\(/i,
+    name: "collect() function",
+    errorMessage: "collect() aggregation function is not supported. Aggregation functions are not available."
+  },
+  {
+    pattern: /\bMIN\s*\(/i,
+    name: "MIN() function",
+    errorMessage: "MIN() aggregation function is not supported. Aggregation functions are not available."
+  },
+  {
+    pattern: /\bMAX\s*\(/i,
+    name: "MAX() function",
+    errorMessage: "MAX() aggregation function is not supported. Aggregation functions are not available."
+  },
+  {
+    pattern: /\bAVG\s*\(/i,
+    name: "AVG() function",
+    errorMessage: "AVG() aggregation function is not supported. Aggregation functions are not available."
+  }
+];
+var FORBIDDEN_MODIFIERS = [
+  {
+    pattern: /\bSKIP\b/i,
+    name: "SKIP clause",
+    errorMessage: "SKIP clause is not supported. Pagination is not available."
+  }
+];
+var FORBIDDEN_PATTERNS = [
+  {
+    pattern: /\[.*:\w+\*\d+\.\.\d+.*\]/,
+    name: "Path range syntax",
+    errorMessage: "Path range syntax is not supported. Patterns like `*1..3`, `*2..`, `*..3` are invalid.",
+    alternative: "Use `*` (unlimited, zero or more) for variable-length paths."
+  },
+  {
+    pattern: /\[.*:\w+\*\d+\.\..*\]/,
+    name: "Path range syntax (lower bound)",
+    errorMessage: "Path range syntax is not supported. Patterns like `*2..` are invalid.",
+    alternative: "Use `*` (unlimited, zero or more) for variable-length paths."
+  },
+  {
+    pattern: /\[.*:\w+\*\.\.\d+.*\]/,
+    name: "Path range syntax (upper bound)",
+    errorMessage: "Path range syntax is not supported. Patterns like `*..3` are invalid.",
+    alternative: "Use `*` (unlimited, zero or more) for variable-length paths."
+  },
+  {
+    pattern: /WHERE\s+NOT\s*\(/i,
+    name: "WHERE NOT (pattern)",
+    errorMessage: "WHERE NOT (pattern) is not supported. Cannot use pattern negation in WHERE clause.",
+    alternative: "Use `OPTIONAL MATCH` + `WHERE IS NULL` instead. Example: `OPTIONAL MATCH (m)-[:HAS_PARAMETER]->(:ParameterDeclaration) WHERE ... IS NULL`."
+  },
+  {
+    pattern: /MATCH\s*\(:\w+[^)]*\)(?:\s*,\s*\(:\w+[^)]*\))*(?:\s*WHERE[^R]*)?/i,
+    name: "Anonymous-only queries",
+    errorMessage: "Queries with only anonymous nodes (no variable bindings) are not useful.",
+    alternative: "Use bound variables in the pattern. Example: `MATCH (a:A)` instead of `MATCH (:A)`."
+  }
+];
+
+// libs/cli/code-graph-core/src/lib/cypher/lib/validator/query-validator.ts
+var UNSUPPORTED_FEATURES = [
+  ...FORBIDDEN_KEYWORDS,
+  ...FORBIDDEN_AGGREGATIONS,
+  ...FORBIDDEN_MODIFIERS,
+  ...FORBIDDEN_PATTERNS
+];
+var UnsupportedFeatureError = class extends Error {
+  constructor(feature, query2) {
+    const message = `Unsupported Cypher feature detected: ${feature.name}
+
+${feature.errorMessage}${feature.alternative ? `
+
+Alternative: ${feature.alternative}` : ""}
+
+Query: ${query2}`;
+    super(message);
+    this.feature = feature;
+    this.query = query2;
+    this.name = "UnsupportedFeatureError";
+  }
+};
+function validateQuery(query2) {
+  if (!query2 || typeof query2 !== "string") {
+    throw new Error("Query must be a non-empty string");
+  }
+  const normalizedQuery = query2.trim();
+  if (normalizedQuery.length === 0) {
+    throw new Error("Query cannot be empty");
+  }
+  for (const feature of UNSUPPORTED_FEATURES) {
+    const pattern = typeof feature.pattern === "string" ? new RegExp(feature.pattern, "i") : feature.pattern;
+    if (pattern.test(normalizedQuery)) {
+      if (feature.name === "WITH clause") {
+        const withMatches = normalizedQuery.matchAll(/\bWITH\b/gi);
+        let isAllowed = false;
+        for (const match of withMatches) {
+          const beforeMatch = normalizedQuery.substring(
+            Math.max(0, match.index - 10),
+            match.index
+          );
+          if (/\bSTARTS\s+$/i.test(beforeMatch) || /\bENDS\s+$/i.test(beforeMatch)) {
+            isAllowed = true;
+            break;
+          }
+        }
+        if (isAllowed) {
+          continue;
+        }
+      }
+      throw new UnsupportedFeatureError(feature, normalizedQuery);
+    }
+  }
+}
+
+// libs/cli/code-graph-core/src/lib/cypher/lib/index.ts
+var buildQueryObject = (query2) => {
+  const joinedQuery = Array.isArray(query2) ? query2.join(" ") : query2;
+  validateQuery(joinedQuery);
+  const lexer = new Lexer(joinedQuery);
+  const tokens = lexer.tokenize();
+  const parser = new Parser(tokens);
+  return parser.parse();
+};
+var query = (queryStatements, graph) => {
+  const queryObject = buildQueryObject(queryStatements);
+  const executor = new CypherExecutor(graph);
+  return executor.execute(queryObject);
+};
+
+// libs/cli/code-graph-core/src/lib/code-graph-core.ts
+var matchFromGeneratedFiles = (cypherQuery, config, generatedFiles) => {
+  const fileSystem = generatedFiles.reduce((acc, file) => {
+    if (file.filePath.endsWith(".ts")) {
+      acc[file.filePath] = file.code;
+    }
+    return acc;
+  }, {});
+  return matchFromFileSystem(cypherQuery, config, fileSystem);
+};
+var matchFromFileSystem = (cypherQuery, config, fileSystem) => {
+  const program = createProgramFromFileSystem(fileSystem);
+  const codeGraph = buildCodeGraph(program, config);
+  const results = query(cypherQuery, codeGraph);
+  return results;
+};
+var mapGeneratedFilesToFileSystem = (generatedFiles) => {
+  return generatedFiles.reduce(
+    (acc, file) => {
+      acc[file.filePath] = file.code;
+      return acc;
+    },
+    {}
+  );
+};
+var resolveProgramFromConfig = (env) => {
+  return env.tsConfig ? createProgramFromTsConfig(env.tsConfig) : createProgramFromFileSystem(
+    mapGeneratedFilesToFileSystem(env.generatedFiles)
+  );
+};
+var autoMatch = (cypherQuery, program, options) => {
+  const queryObject = buildQueryObject(cypherQuery);
+  const config = buildConfigFromQuery(queryObject);
+  const codeGraph = buildCodeGraph(program, config);
+  const results = query(cypherQuery, codeGraph);
+  return options?.skipRewrite ? results : rewriteOccurenceOf(results);
+};
+var PATH_ANCHOR_SRC_APP = "src/app";
+var rewriteUntilPath = (pathOrNodeId, pathAnchor) => {
+  const searchSegment = pathAnchor.startsWith("/") && pathAnchor.endsWith("/") ? pathAnchor : `/${pathAnchor.replace(/^\/|\/$/g, "")}/`;
+  const idx = pathOrNodeId.lastIndexOf(searchSegment);
+  if (idx < 0)
+    return pathOrNodeId;
+  const sliced = pathOrNodeId.slice(idx);
+  return sliced.startsWith("/") ? sliced.slice(1) : sliced;
+};
+var rewriteOccurenceOf = (result) => {
+  return result.map((result2) => {
+    return Object.keys(result2).reduce((acc, key) => {
+      if (!result2[key]) {
+        return acc;
+      }
+      const id = result2[key]["id"];
+      if (!id) {
+        return acc;
+      }
+      return {
+        ...acc,
+        [key]: {
+          ...result2[key],
+          id: rewriteUntilPath(id, PATH_ANCHOR_SRC_APP)
+        }
+      };
+    }, {});
+  });
+};
+var filterResultsByGeneratedFiles = (results, generatedFiles) => {
+  const filePaths = generatedFiles.map((file) => file.filePath);
+  return results.filter(
+    (result) => Object.values(result).find(
+      (n) => filePaths.includes(n["id"].split(".")[0] + ".ts")
+    )
+  );
+};
+var autoMatchFromGeneratedFiles = (cypherQuery, generatedFiles) => {
+  const queryObject = buildQueryObject(cypherQuery);
+  const config = buildConfigFromQuery(queryObject);
+  return matchFromGeneratedFiles(cypherQuery, config, generatedFiles);
+};
+var NODE_PROPERTIES_PRESET = {
+  NAMEABLE: {
+    name: `helpers.getDescendantsBy(args.current, (node) => node.kind === args.ts.SyntaxKind.Identifier)[0]?.getText();`,
+    filePath: "args.sourceFile.fileName;"
+  },
+  /**
+   * Creates a preset that extracts a property value from an ObjectLiteralExpression
+   * @param key - The property name to look for in the object literal
+   * @returns An extractor code string that finds the property and returns its initializer text
+   *
+   * @example
+   * ```typescript
+   * properties: {
+   *   selector: NODE_PROPERTIES_PRESET.OBJECT_PROPERTY('selector'),
+   *   template: NODE_PROPERTIES_PRESET.OBJECT_PROPERTY('template'),
+   * }
+   * ```
+   */
+  OBJECT_LITERAL_PROPERTY: (key, valueFns = []) => {
+    return `(function() {
+      const objectLiterals = helpers.getDescendantsBy(
+        args.current, 
+        (node) => node.kind === args.ts.SyntaxKind.ObjectLiteralExpression
+      );
+      
+      for (const objLiteral of objectLiterals) {
+        if (args.ts.isObjectLiteralExpression(objLiteral)) {
+          for (const property of objLiteral.properties) {
+            if (args.ts.isPropertyAssignment(property)) {
+              const propName = property.name;
+              let propNameText = '';
+              
+              if (args.ts.isIdentifier(propName)) {
+                propNameText = propName.text;
+              } else if (args.ts.isStringLiteral(propName)) {
+                propNameText = propName.text;
+              }
+              
+              if (propNameText === '${key}') {
+                const value = property.initializer?.getText() || null;
+                return [${valueFns.join(", ")}].reduce((acc, valueFn) => valueFn(acc), value);
+              }
+            }
+          }
+        }
+      }
+      return null;
+    })();`;
+  }
+};
+export {
+  NODE_PROPERTIES_PRESET,
+  autoMatch,
+  autoMatchFromGeneratedFiles,
+  createProgramFromFileSystem,
+  createProgramFromTsConfig,
+  extractFromNodeId,
+  filterResultsByGeneratedFiles,
+  matchFromFileSystem,
+  matchFromGeneratedFiles,
+  resolveProgramFromConfig,
+  rewriteUntilPath
+};