@lowgular/code-graph 0.0.1

package/apps/code-graph/src/main.js

@@ -0,0 +1,50 @@
+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 main_exports = {};
+__export(main_exports, {
+  NODE_PRESETS: () => NODE_PRESETS,
+  matchFromFileSystem: () => matchFromFileSystem,
+  matchFromTsConfig: () => matchFromTsConfig
+});
+module.exports = __toCommonJS(main_exports);
+var import_code_graph = require("@cli/code-graph");
+var import_codegular = require("@core/codegular");
+const matchFromTsConfig = async (cypherQuery, tsConfigPath = "./tsconfig.json") => {
+  const program = (0, import_codegular.createProgramFromTsConfig)(tsConfigPath);
+  return [];
+};
+const matchFromFileSystem = async (cypherQuery, config, fileSystem) => {
+  const program = (0, import_codegular.createProgramFromFileSystem)(fileSystem);
+  const codeGraph = (0, import_code_graph.buildCodeGraph)(program, config);
+  const results = await import_code_graph.TOOLS.queryFromGraph(cypherQuery, codeGraph);
+  return results;
+};
+const NODE_PRESETS = {
+  NAMEABLE: {
+    properties: {
+      name: `helpers.getDescendantsBy(args.current, (node) => node.kind === args.ts.SyntaxKind.Identifier)[0]?.getText();`,
+      filePath: "args.sourceFile.fileName;"
+    }
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  NODE_PRESETS,
+  matchFromFileSystem,
+  matchFromTsConfig
+});

package/libs/cli/code-graph/src/index.js

@@ -0,0 +1,39 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var src_exports = {};
+module.exports = __toCommonJS(src_exports);
+__reExport(src_exports, require("./lib/class-declarations"), module.exports);
+__reExport(src_exports, require("./lib/code.graph.factory"), module.exports);
+__reExport(src_exports, require("./lib/core/core"), module.exports);
+__reExport(src_exports, require("./lib/decorators"), module.exports);
+__reExport(src_exports, require("./lib/docs"), module.exports);
+__reExport(src_exports, require("./lib/method-declarations"), module.exports);
+__reExport(src_exports, require("./lib/parameters"), module.exports);
+__reExport(src_exports, require("./lib/property-declarations"), module.exports);
+__reExport(src_exports, require("./lib/tools"), module.exports);
+__reExport(src_exports, require("./lib/v2"), module.exports);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ...require("./lib/class-declarations"),
+  ...require("./lib/code.graph.factory"),
+  ...require("./lib/core/core"),
+  ...require("./lib/decorators"),
+  ...require("./lib/docs"),
+  ...require("./lib/method-declarations"),
+  ...require("./lib/parameters"),
+  ...require("./lib/property-declarations"),
+  ...require("./lib/tools"),
+  ...require("./lib/v2")
+});

package/libs/cli/code-graph/src/lib/class-declarations/abstractions/service.js

@@ -0,0 +1,72 @@
+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 service_exports = {};
+__export(service_exports, {
+  SERVICE_CLASS_ABSTRACTION: () => SERVICE_CLASS_ABSTRACTION,
+  SERVICE_CLASS_EXAMPLES: () => SERVICE_CLASS_EXAMPLES,
+  SERVICE_CLASS_MATCH_QUERY: () => SERVICE_CLASS_MATCH_QUERY,
+  SERVICE_STUB: () => SERVICE_STUB
+});
+module.exports = __toCommonJS(service_exports);
+const SERVICE_STUB = `
+export class DecoratorlessService { }
+
+@Injectable({ providedIn: 'root' })
+export class InjectableService { }
+
+`;
+const SERVICE_CLASS_MATCH_QUERY = `OPTIONAL MATCH (c)-[:HAS_DECORATOR]->(d:Decorator)
+WHERE d IS NULL OR d.name = 'Injectable'`;
+const SERVICE_CLASS_EXAMPLES = [
+  {
+    userPrompt: "Find all service classes",
+    given: SERVICE_STUB,
+    when: `MATCH (c:ClassDeclaration)
+    ${SERVICE_CLASS_MATCH_QUERY}
+RETURN c`,
+    then: [
+      [
+        {
+          labels: ["ClassDeclaration"],
+          name: "DecoratorlessService"
+        }
+      ],
+      [
+        {
+          labels: ["ClassDeclaration"],
+          name: "InjectableService"
+        }
+      ]
+    ]
+  }
+];
+const SERVICE_CLASS_ABSTRACTION = {
+  id: "service-class",
+  name: "ServiceClass",
+  schema: {},
+  relationships: {},
+  description: `Abstraction on top of the TypeScript ClassDeclaration that provides reusable functionality and business logic. It encapsulates operations that can be shared across multiple components or other services.`,
+  examples: SERVICE_CLASS_EXAMPLES
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  SERVICE_CLASS_ABSTRACTION,
+  SERVICE_CLASS_EXAMPLES,
+  SERVICE_CLASS_MATCH_QUERY,
+  SERVICE_STUB
+});

package/libs/cli/code-graph/src/lib/class-declarations/abstractions/service.stateful.js

@@ -0,0 +1,68 @@
+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 service_stateful_exports = {};
+__export(service_stateful_exports, {
+  CLASS_SERVICE_STATEFUL_ABSTRACTION: () => CLASS_SERVICE_STATEFUL_ABSTRACTION,
+  STATEFULL_SERVICE_STUB: () => STATEFULL_SERVICE_STUB,
+  STATEFUL_SERVICE_CLASS_EXAMPLES: () => STATEFUL_SERVICE_CLASS_EXAMPLES
+});
+module.exports = __toCommonJS(service_stateful_exports);
+var import_core = require("../../core/core");
+var import_property_declarations = require("../../property-declarations");
+var import_service = require("./service");
+const STATEFULL_SERVICE_STUB = `
+import { Subject } from 'rxjs';
+
+${import_service.SERVICE_STUB}
+
+@Injectable({ providedIn: 'root' })
+export class StatefullService {
+  private readonly state = new Subject<number>();
+}
+`;
+const STATEFUL_SERVICE_CLASS_EXAMPLES = [
+  {
+    userPrompt: "Find all stateful service classes",
+    given: STATEFULL_SERVICE_STUB,
+    when: `MATCH (c:ClassDeclaration)-[:HAS_PROPERTY]->${import_property_declarations.REACTIVE_STATE_PROPERTY_MATCH_QUERY}
+${import_service.SERVICE_CLASS_MATCH_QUERY}
+RETURN c`,
+    then: [
+      [
+        {
+          labels: ["ClassDeclaration"],
+          name: "StatefullService"
+        }
+      ]
+    ]
+  }
+];
+const CLASS_SERVICE_STATEFUL_ABSTRACTION = {
+  id: "service-class-stateful",
+  name: "Stateful Service Class",
+  description: `Abstraction that extends ${(0, import_core.ml)(import_service.SERVICE_CLASS_ABSTRACTION)} with internal state using ${(0, import_core.ml)(import_property_declarations.REACTIVE_STATE_PROPERTY_ABSTRACTION)}`,
+  schema: {},
+  relationships: {},
+  examples: STATEFUL_SERVICE_CLASS_EXAMPLES
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  CLASS_SERVICE_STATEFUL_ABSTRACTION,
+  STATEFULL_SERVICE_STUB,
+  STATEFUL_SERVICE_CLASS_EXAMPLES
+});

package/libs/cli/code-graph/src/lib/class-declarations/class-declarations.doc.js

@@ -0,0 +1,147 @@
+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 class_declarations_doc_exports = {};
+__export(class_declarations_doc_exports, {
+  CLASS_DECLARATION_DOC: () => CLASS_DECLARATION_DOC,
+  CLASS_DECLARATION_EDGE_TYPES: () => CLASS_DECLARATION_EDGE_TYPES,
+  CLASS_DECLARATION_EXAMPLES: () => CLASS_DECLARATION_EXAMPLES,
+  SNIPPETS: () => SNIPPETS
+});
+module.exports = __toCommonJS(class_declarations_doc_exports);
+var import_core = require("../core/core");
+var import_method_declarations = require("../method-declarations/method-declarations.doc");
+const SNIPPETS = {
+  singleClassMultipleMemebers: `class Test {
+  num = 1;
+  str = 'test';
+  bool = true;
+
+  queryMethod() {
+    return this.num;
+  }
+
+  commandMethod(param1: number) {
+    this.num = this.num + param1;
+  }
+}`,
+  injectableClass: `@Injectable({ providedIn: 'root' })
+export class TestService { }`
+};
+var CLASS_DECLARATION_EDGE_TYPES = /* @__PURE__ */ ((CLASS_DECLARATION_EDGE_TYPES2) => {
+  CLASS_DECLARATION_EDGE_TYPES2["HAS_DECORATOR"] = "HAS_DECORATOR";
+  CLASS_DECLARATION_EDGE_TYPES2["HAS_PROPERTY"] = "HAS_PROPERTY";
+  CLASS_DECLARATION_EDGE_TYPES2["HAS_METHOD"] = "HAS_METHOD";
+  return CLASS_DECLARATION_EDGE_TYPES2;
+})(CLASS_DECLARATION_EDGE_TYPES || {});
+const CLASS_DECLARATION_EXAMPLES = [
+  {
+    userPrompt: "Find all classes",
+    given: SNIPPETS.singleClassMultipleMemebers,
+    when: `MATCH (classDecl:ClassDeclaration) RETURN classDecl`,
+    then: [
+      [
+        {
+          labels: ["ClassDeclaration"],
+          name: "Test"
+        }
+      ]
+    ]
+  },
+  {
+    userPrompt: "Find all properties of all classes",
+    given: SNIPPETS.singleClassMultipleMemebers,
+    when: `MATCH (classDecl:ClassDeclaration)-[:${"HAS_PROPERTY" /* HAS_PROPERTY */}]->(propDecl:PropertyDeclaration) RETURN classDecl, propDecl`,
+    then: [
+      [
+        {
+          labels: ["ClassDeclaration"],
+          name: "Test"
+        },
+        { labels: ["PropertyDeclaration"], name: "num" }
+      ],
+      [
+        {
+          labels: ["ClassDeclaration"],
+          name: "Test"
+        },
+        { labels: ["PropertyDeclaration"], name: "str" }
+      ],
+      [
+        {
+          labels: ["ClassDeclaration"],
+          name: "Test"
+        },
+        { labels: ["PropertyDeclaration"], name: "bool" }
+      ]
+    ]
+  },
+  {
+    userPrompt: "Find all parameters of all methods and all classes",
+    given: SNIPPETS.singleClassMultipleMemebers,
+    when: `MATCH (n:ClassDeclaration)-[rel1:${"HAS_METHOD" /* HAS_METHOD */}]->(m:MethodDeclaration)-[rel2:${import_method_declarations.METHOD_DECLARATION_EDGE_TYPES.HAS_PARAMETER}]->(p:Parameter) RETURN n, m, p`,
+    then: [
+      [
+        {
+          labels: ["ClassDeclaration"],
+          name: "Test"
+        },
+        {
+          labels: ["MethodDeclaration"],
+          name: "commandMethod"
+        },
+        {
+          labels: ["Parameter"],
+          name: "param1"
+        }
+      ]
+    ]
+  }
+];
+const CLASS_DECLARATION_DOC = {
+  id: "class-declaration",
+  name: "ClassDeclaration",
+  schema: {
+    ...import_core.NameableSchema
+  },
+  relationships: {
+    ["HAS_DECORATOR" /* HAS_DECORATOR */]: {
+      examples: [
+        `(c:ClassDeclaration)-[:${"HAS_DECORATOR" /* HAS_DECORATOR */}]->(d:Decorator)`
+      ]
+    },
+    ["HAS_PROPERTY" /* HAS_PROPERTY */]: {
+      examples: [
+        `(c:ClassDeclaration)-[:${"HAS_PROPERTY" /* HAS_PROPERTY */}]->(p:PropertyDeclaration)`
+      ]
+    },
+    ["HAS_METHOD" /* HAS_METHOD */]: {
+      examples: [
+        `(c:ClassDeclaration)-[:${"HAS_METHOD" /* HAS_METHOD */}]->(m:MethodDeclaration)`
+      ]
+    }
+  },
+  description: `The node represents TypeScript AST kind: ClassDeclaration.`,
+  examples: CLASS_DECLARATION_EXAMPLES
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  CLASS_DECLARATION_DOC,
+  CLASS_DECLARATION_EDGE_TYPES,
+  CLASS_DECLARATION_EXAMPLES,
+  SNIPPETS
+});

package/libs/cli/code-graph/src/lib/class-declarations/class-declarations.graph.js

@@ -0,0 +1,55 @@
+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 class_declarations_graph_exports = {};
+__export(class_declarations_graph_exports, {
+  appendClassGraph: () => appendClassGraph
+});
+module.exports = __toCommonJS(class_declarations_graph_exports);
+var import_typescript = require("@cli/typescript");
+var import_code = require("../code.graph");
+var import_core = require("../core/core");
+var import_method_declarations = require("../method-declarations/method-declarations.graph");
+var import_property_declarations = require("../property-declarations/property-declarations.graph");
+var import_class_declarations = require("./class-declarations.doc");
+const ts = require("typescript");
+const appendClassGraph = (codeGraph, classDeclaration, context) => {
+  const classImplementation = new import_typescript.ClassImplementation(
+    classDeclaration,
+    context
+  );
+  const classNode = (0, import_core.extendNameable)(classImplementation);
+  (0, import_code.addNode)(codeGraph, classNode);
+  appendClassDecoratorsGraph(codeGraph, classNode.id, classImplementation);
+  (0, import_property_declarations.appendClassPropertiesGraph)(codeGraph, classNode.id, classImplementation);
+  (0, import_method_declarations.appendClassMethodsGraph)(codeGraph, classNode.id, classImplementation);
+};
+const appendClassDecoratorsGraph = (codeGraph, classId, classImplementation) => {
+  classImplementation.decorators.forEach((d) => {
+    const decoratorNode = (0, import_core.extendNameable)(d);
+    (0, import_code.addNode)(codeGraph, decoratorNode);
+    (0, import_code.addEdge)(codeGraph, {
+      source: classId,
+      target: decoratorNode.id,
+      type: import_class_declarations.CLASS_DECLARATION_EDGE_TYPES.HAS_DECORATOR
+    });
+  });
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  appendClassGraph
+});

package/libs/cli/code-graph/src/lib/class-declarations/index.js

@@ -0,0 +1,27 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var class_declarations_exports = {};
+module.exports = __toCommonJS(class_declarations_exports);
+__reExport(class_declarations_exports, require("./abstractions/service"), module.exports);
+__reExport(class_declarations_exports, require("./abstractions/service.stateful"), module.exports);
+__reExport(class_declarations_exports, require("./class-declarations.doc"), module.exports);
+__reExport(class_declarations_exports, require("./class-declarations.graph"), module.exports);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ...require("./abstractions/service"),
+  ...require("./abstractions/service.stateful"),
+  ...require("./class-declarations.doc"),
+  ...require("./class-declarations.graph")
+});

package/libs/cli/code-graph/src/lib/code.graph.factory.js

@@ -0,0 +1,63 @@
+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 code_graph_factory_exports = {};
+__export(code_graph_factory_exports, {
+  makeCodeGraphFromSourceFiles: () => makeCodeGraphFromSourceFiles
+});
+module.exports = __toCommonJS(code_graph_factory_exports);
+var import_typescript = require("@cli/typescript");
+var import_codegular = require("@core/codegular");
+var import_class_declarations = require("./class-declarations/class-declarations.graph");
+const ts = require("typescript");
+const makeCodeGraphFromSourceFiles = (program) => {
+  const codeGraph = {
+    nodesById: {},
+    edgesBySource: {},
+    edgesByTarget: {}
+  };
+  const sourceFiles = (0, import_codegular.getSolutionSourceFiles)(program);
+  const context = {
+    typeChecker: program.getTypeChecker(),
+    typeResolutionTracker: new import_typescript.TypeResolutionTracker(),
+    declarationRegistry: new import_typescript.DeclarationRegistry()
+  };
+  const counter = {
+    files: 0,
+    classes: 0
+  };
+  sourceFiles.forEach((sourceFile) => {
+    const classDeclarations = (0, import_codegular.findChildrenByKind)(
+      sourceFile,
+      ts.SyntaxKind.ClassDeclaration
+    );
+    counter.files++;
+    classDeclarations.forEach((classDeclaration) => {
+      (0, import_class_declarations.appendClassGraph)(
+        codeGraph,
+        classDeclaration,
+        context
+      );
+      counter.classes++;
+    });
+  });
+  return codeGraph;
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  makeCodeGraphFromSourceFiles
+});

package/libs/cli/code-graph/src/lib/code.graph.js

@@ -0,0 +1,62 @@
+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 code_graph_exports = {};
+__export(code_graph_exports, {
+  addEdge: () => addEdge,
+  addNode: () => addNode
+});
+module.exports = __toCommonJS(code_graph_exports);
+const ts = require("typescript");
+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;
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  addEdge,
+  addNode
+});

package/libs/cli/code-graph/src/lib/core/core.js

@@ -0,0 +1,58 @@
+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 core_exports = {};
+__export(core_exports, {
+  NameableSchema: () => NameableSchema,
+  extendNameable: () => extendNameable,
+  generateNodeId: () => generateNodeId,
+  ml: () => ml
+});
+module.exports = __toCommonJS(core_exports);
+const generateNodeId = (node) => `${node.filePath}.${node.range.start.line}.${node.range.start.character}.${node.range.end.line}.${node.range.end.character}`;
+const extendNameable = (node, extraProps = {}) => {
+  return {
+    ...extraProps,
+    id: generateNodeId(node),
+    name: node.name,
+    range: node.range,
+    filePath: node.filePath,
+    labels: [node.kind]
+  };
+};
+const NameableSchema = {
+  name: "string",
+  filePath: "string",
+  range: {
+    start: {
+      line: "number",
+      column: "number"
+    },
+    end: {
+      line: "number",
+      column: "number"
+    }
+  }
+};
+const ml = (nodeDoc) => `[${nodeDoc.name}](${`codegraph://docs/${nodeDoc.id}`})`;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  NameableSchema,
+  extendNameable,
+  generateNodeId,
+  ml
+});