@lowgular/code-graph 0.0.1 → 0.1.1

package/bin/cli.js

@@ -0,0 +1,10 @@
+#!/usr/bin/env node
+import yargs from "yargs";
+import { hideBin } from "yargs/helpers";
+import * as QueryModule from "../run-cli.js";
+import * as ResourcesModule from "../resources-cli.js";
+import * as CypherModule from "../cypher-cli.js";
+const VERSION = process.env.npm_package_version ?? "0.1.0";
+yargs(hideBin(process.argv)).scriptName("code-graph").demandCommand().recommendCommands().command(QueryModule.command, QueryModule.describe, QueryModule).command(ResourcesModule.command, ResourcesModule.describe, ResourcesModule).command(CypherModule.command, CypherModule.describe, CypherModule).wrap(120).strict().help().version(VERSION).epilog(
+  'Exits 0 and prints JSON array of matches to stdout on success; exits 1 and prints error to stderr on failure.\n\nExamples:\n  code-graph query "MATCH (n:ClassDeclaration) RETURN n"\n  code-graph query --tsconfig ./lib/tsconfig.json "MATCH (n:ClassDeclaration) RETURN n"\n  code-graph resources   # schema and concepts\n  code-graph cypher      # full Cypher dialect reference'
+).parse();

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

@@ -0,0 +1,37 @@
+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

@@ -0,0 +1,131 @@
+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

@@ -0,0 +1,27 @@
+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

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

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

@@ -0,0 +1,49 @@
+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

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

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

@@ -0,0 +1,22 @@
+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/{libs/cli/code-graph/src/lib/v2 → code-graph-v2}/graph-builder/relationship.processor.js

@@ -1,30 +1,7 @@
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var relationship_processor_exports = {};
-__export(relationship_processor_exports, {
-  processRelationships: () => processRelationships
-});
-module.exports = __toCommonJS(relationship_processor_exports);
-var import_typescript = require("@cli/typescript");
-var import_extractors = require("../extractors");
-var import_node = require("./node.processor");
-var import_type = require("./type.processor");
-const ts = require("typescript");
+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";
 }
@@ -37,27 +14,27 @@ const processRelationships = (parentId, context, nodeConfig, codeGraph) => {
       const relationshipExtractorFnCode = nodeConfig.relationships[relationshipName].extractorCode;
       const relationshipNodeExtractors = nodeConfig.relationships[relationshipName].nodeExtractors;
       Object.keys(relationshipNodeExtractors).forEach((label) => {
-        const children = (0, import_extractors.executeExtractor)(relationshipExtractorFnCode, context);
+        const children = executeExtractor(relationshipExtractorFnCode, context);
         children.forEach(
           (child) => {
             if (isTsType(child)) {
-              const childNode = (0, import_type.processType)(
+              const childNode = processType(
                 { ...context, args: { ...context.args, current: child } },
                 relationshipNodeExtractors,
                 codeGraph
               );
-              (0, import_typescript.addEdge)(codeGraph, {
+              addEdge(codeGraph, {
                 source: parentId,
                 target: childNode.id,
                 type: relationshipName
               });
             } else if (isTsNode(child)) {
-              const childNode = (0, import_node.processNode)(
+              const childNode = processNode(
                 { ...context, args: { ...context.args, current: child } },
                 relationshipNodeExtractors,
                 codeGraph
               );
-              (0, import_typescript.addEdge)(codeGraph, {
+              addEdge(codeGraph, {
                 source: parentId,
                 target: childNode.id,
                 type: relationshipName
@@ -73,7 +50,6 @@ const processRelationships = (parentId, context, nodeConfig, codeGraph) => {
     }
   }
 };
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
+export {
   processRelationships
-});
+};

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

@@ -0,0 +1,21 @@
+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

@@ -0,0 +1,4 @@
+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

@@ -0,0 +1,19 @@
+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

@@ -0,0 +1,34 @@
+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

@@ -0,0 +1,5 @@
+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

@@ -0,0 +1,71 @@
+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

@@ -0,0 +1,100 @@
+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
+};