@lowgular/code-graph 0.1.1 → 0.1.2

package/package.json

@@ -1,12 +1,13 @@
 {
   "name": "@lowgular/code-graph",
-  "version": "0.1.1",
+  "version": "0.1.2",
   "description": "Run Cypher queries against a TypeScript code graph built from tsconfig",
   "license": "MIT",
   "type": "module",
   "main": "./bin/cli.js",
   "exports": {
-    ".": "./bin/cli.js"
+    ".": "./bin/cli.js",
+    "./lib": "./lib.js"
   },
   "bin": {
     "code-graph": "./bin/cli.js"

package/code-graph-v2/code.graph.js

@@ -1,37 +0,0 @@
-const addNode = (graph, node) => {
-  graph.nodesById[node.id] = node;
-  return graph;
-};
-const getEdgeKey = (edge) => {
-  return `${edge.source}|${edge.target}|${edge.type}`;
-};
-const 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;
-};
-export {
-  addEdge,
-  addNode
-};

package/code-graph-v2/config-from-query.js

@@ -1,131 +0,0 @@
-const 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; } })()`
-};
-const 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] : []; })()`
-};
-const buildConfigFromQuery = (query) => {
-  const nodeExtractors = {};
-  const matchStatements = query.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 };
-};
-const resolveLabels = (pattern, variableToLabels) => {
-  if (pattern.labels.length > 0)
-    return pattern.labels;
-  if (pattern.variable && variableToLabels[pattern.variable]) {
-    return variableToLabels[pattern.variable];
-  }
-  return [];
-};
-const 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;
-  }
-};
-const 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;
-};
-const 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;
-};
-const buildKindFilter = (labels) => {
-  return labels.map((l) => `node.kind === args.ts.SyntaxKind.${l}`).join(" || ");
-};
-export {
-  buildConfigFromQuery
-};

package/code-graph-v2/extractors/extractor.js

@@ -1,27 +0,0 @@
-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;
-}
-export {
-  executeExtractor,
-  extractNodeProperties
-};

package/code-graph-v2/extractors/index.js

@@ -1 +0,0 @@
-export * from "./extractor.js";

package/code-graph-v2/graph-builder/code-graph.builder.js

@@ -1,49 +0,0 @@
-import * as ts from "typescript";
-import {
-  getAncestorsBy,
-  getDescendantsBy,
-  getDescendantsByKind,
-  getSolutionSourceFiles
-} from "../../codegular/index.js";
-import { processNode } from "./node.processor.js";
-const 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, ts.SyntaxKind[kindName]);
-      nodes.forEach((node) => {
-        const extractorContext = {
-          args: {
-            current: node,
-            sourceFile,
-            typeChecker: program.getTypeChecker(),
-            ts
-          },
-          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;
-};
-export {
-  buildCodeGraph
-};

package/code-graph-v2/graph-builder/index.js

@@ -1 +0,0 @@
-export * from "./code-graph.builder.js";

package/code-graph-v2/graph-builder/node.processor.js

@@ -1,22 +0,0 @@
-import { addNode } from "../code.graph.js";
-import {
-  extractNodeProperties
-} from "../extractors/index.js";
-import { generateNodeId, getSyntaxKindName } from "../utils.js";
-import { processRelationships } from "./relationship.processor.js";
-const 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;
-};
-export {
-  processNode
-};

package/code-graph-v2/graph-builder/relationship.processor.js

@@ -1,55 +0,0 @@
-import { addEdge } from "../code.graph.js";
-import { executeExtractor } from "../extractors/index.js";
-import { processNode } from "./node.processor.js";
-import { processType } from "./type.processor.js";
-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);
-}
-const 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`
-              );
-            }
-          }
-        );
-      });
-    }
-  }
-};
-export {
-  processRelationships
-};

package/code-graph-v2/graph-builder/type.processor.js

@@ -1,21 +0,0 @@
-import { addNode } from "../code.graph.js";
-import { extractNodeProperties } from "../extractors/index.js";
-import { processRelationships } from "./relationship.processor.js";
-const 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;
-};
-export {
-  processType
-};

package/code-graph-v2/index.js

@@ -1,4 +0,0 @@
-export * from "./config-from-query.js";
-export * from "./extractors/index.js";
-export * from "./graph-builder/index.js";
-export * from "./tools/build-code-graph.tool.js";

package/code-graph-v2/tools/build-code-graph.tool.js

@@ -1,19 +0,0 @@
-import { writeFileSync } from "fs";
-import { createProgramFromTsConfig } from "../../codegular/index.js";
-import { buildCodeGraph } from "../graph-builder/index.js";
-async function buildCodeGraphTool(tsConfigPath, config) {
-  const program = createProgramFromTsConfig(tsConfigPath);
-  const graph = buildCodeGraph(program, config);
-  const nodeCount = Object.keys(graph.nodesById).length;
-  const edgeCount = Object.values(graph.edgesBySource).flat().length;
-  const graphPath = tsConfigPath.replace("tsconfig.json", "code-graph.json");
-  writeFileSync(graphPath, JSON.stringify(graph, null, 2));
-  return {
-    graphPath,
-    nodeCount,
-    edgeCount
-  };
-}
-export {
-  buildCodeGraphTool
-};

package/code-graph-v2/utils.js

@@ -1,34 +0,0 @@
-import ts from "typescript";
-const getSyntaxKindName = (kind) => {
-  return ts.SyntaxKind[kind];
-};
-const 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}`;
-};
-const 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)
-    }
-  };
-};
-export {
-  extractFromNodeId,
-  generateNodeId,
-  getSyntaxKindName
-};

package/codegular/index.js

@@ -1,5 +0,0 @@
-export * from "./node.js";
-export * from "./program.js";
-export * from "./string.js";
-export * from "./type-checker.js";
-export * from "./utils.js";

package/codegular/node.js

@@ -1,71 +0,0 @@
-import * as ts from "typescript";
-import { getNameByIdentifier } from "./string.js";
-const { forEachChild, SyntaxKind } = ts;
-const hasKind = (kinds) => (child) => kinds.includes(child.kind);
-const hasName = (names) => (child) => names.includes(getNameByIdentifier(child));
-const hasDecorator = (decoratorName) => (child) => findByDecorator(child, decoratorName) !== void 0;
-const hasAnyDecoratorName = (node, decoratorNames) => {
-  const decorators = getChildrenBy(node, hasKind([SyntaxKind.Decorator]));
-  return decorators.find((d) => {
-    return getChildrenBy(d, hasKind([SyntaxKind.CallExpression])).find(
-      (callExpr) => {
-        return decoratorNames.includes(getNameByIdentifier(callExpr));
-      }
-    ) !== void 0;
-  }) !== void 0;
-};
-const every = () => true;
-function getChildrenBy(node, findFunc = every) {
-  const elements = [];
-  forEachChild(node, (child) => {
-    if (!findFunc(child)) {
-      return;
-    }
-    elements.push(child);
-  });
-  return elements;
-}
-function findChildOrThrow(node, findFunc) {
-  let element;
-  forEachChild(node, (child) => {
-    if (element)
-      return;
-    if (findFunc(child)) {
-      element = child;
-      return;
-    }
-  });
-  if (element === void 0) {
-    throw new Error("Could not find child");
-  }
-  return element;
-}
-const getDecoratorName = (d) => {
-  return getNameByIdentifier(
-    getChildrenBy(d, hasKind([SyntaxKind.CallExpression]))[0]
-  );
-};
-const findByDecorator = (node, decoratorName) => {
-  const decorators = getChildrenBy(node, hasKind([SyntaxKind.Decorator]));
-  if (decorators.length === 0) {
-    return void 0;
-  }
-  return decorators.find((d) => {
-    return getChildrenBy(d, hasKind([SyntaxKind.CallExpression])).find(
-      (callExpr) => {
-        return getNameByIdentifier(callExpr) === decoratorName;
-      }
-    ) !== void 0;
-  });
-};
-export {
-  every,
-  findByDecorator,
-  findChildOrThrow,
-  getChildrenBy,
-  getDecoratorName,
-  hasAnyDecoratorName,
-  hasDecorator,
-  hasKind,
-  hasName
-};

package/codegular/program.js

@@ -1,100 +0,0 @@
-import * as path from "path";
-import * as ts from "typescript";
-const createSourceFileFromContent = (fileName, content) => {
-  return ts.createSourceFile(fileName, content, ts.ScriptTarget.Latest, true);
-};
-const createProgramFromFileSystem = (fileSystem) => {
-  const compilerOptions = {
-    target: ts.ScriptTarget.ES2020,
-    module: ts.ModuleKind.CommonJS,
-    moduleResolution: ts.ModuleResolutionKind.NodeJs,
-    allowSyntheticDefaultImports: true,
-    esModuleInterop: true,
-    skipLibCheck: true,
-    lib: ["ES2020", "DOM"]
-  };
-  const compilerHost = ts.createCompilerHost(compilerOptions);
-  const originalGetSourceFile = compilerHost.getSourceFile;
-  compilerHost.getSourceFile = (fileName, languageVersion) => {
-    if (fileSystem[fileName]) {
-      return ts.createSourceFile(
-        fileName,
-        fileSystem[fileName],
-        languageVersion,
-        true
-      );
-    }
-    return originalGetSourceFile(fileName, languageVersion);
-  };
-  const fileNames = Object.keys(fileSystem);
-  return ts.createProgram(fileNames, compilerOptions, compilerHost);
-};
-const createHybridProgram = (generatedFiles, options) => {
-  const rootPath = path.resolve(options?.workspaceRoot ?? process.cwd());
-  const fileSystem = {};
-  for (const { filePath, code } of generatedFiles) {
-    const absolutePath = path.isAbsolute(filePath) ? filePath : path.join(rootPath, filePath);
-    fileSystem[absolutePath] = code;
-  }
-  const rootNames = Object.keys(fileSystem).filter(
-    (p) => p.endsWith(".ts")
-  );
-  const compilerOptions = {
-    target: ts.ScriptTarget.ES2020,
-    module: ts.ModuleKind.ESNext,
-    moduleResolution: ts.ModuleResolutionKind.Node10,
-    allowSyntheticDefaultImports: true,
-    esModuleInterop: true,
-    skipLibCheck: true,
-    lib: ["ES2020", "DOM"],
-    strict: true
-  };
-  const compilerHost = ts.createCompilerHost(compilerOptions);
-  const originalGetSourceFile = compilerHost.getSourceFile;
-  compilerHost.getCurrentDirectory = () => rootPath;
-  compilerHost.getSourceFile = (fileName, languageVersion) => {
-    const normalized = path.normalize(fileName);
-    const content = fileSystem[normalized] ?? fileSystem[fileName] ?? fileSystem[path.resolve(rootPath, fileName)];
-    if (content !== void 0) {
-      return ts.createSourceFile(
-        fileName,
-        content,
-        languageVersion,
-        true
-      );
-    }
-    return originalGetSourceFile.call(
-      compilerHost,
-      fileName,
-      languageVersion
-    );
-  };
-  return ts.createProgram(rootNames, compilerOptions, compilerHost);
-};
-const createProgramFromTsConfig = (configPath) => {
-  const configFile = ts.readConfigFile(configPath, ts.sys.readFile);
-  if (configFile.error) {
-    const errorMessage = ts.formatDiagnostic(configFile.error, {
-      getCurrentDirectory: () => process.cwd(),
-      getNewLine: () => "\n",
-      getCanonicalFileName: (fileName) => fileName
-    });
-    throw new Error(`Error reading tsconfig at ${configPath}: ${errorMessage}`);
-  }
-  const parsedConfig = ts.parseJsonConfigFileContent(
-    configFile.config,
-    ts.sys,
-    path.dirname(configPath)
-  );
-  return ts.createProgram(
-    parsedConfig.fileNames,
-    parsedConfig.options,
-    ts.createCompilerHost(parsedConfig.options)
-  );
-};
-export {
-  createHybridProgram,
-  createProgramFromFileSystem,
-  createProgramFromTsConfig,
-  createSourceFileFromContent
-};