@lowgular/code-graph 0.0.1

package/libs/cli/code-graph/src/lib/property-declarations/abstractions/reactive-state.js

@@ -0,0 +1,104 @@
+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 reactive_state_exports = {};
+__export(reactive_state_exports, {
+  PROPERTY_STUB: () => PROPERTY_STUB,
+  REACTIVE_STATE_PROPERTY_ABSTRACTION: () => REACTIVE_STATE_PROPERTY_ABSTRACTION,
+  REACTIVE_STATE_PROPERTY_EXAMPLES: () => REACTIVE_STATE_PROPERTY_EXAMPLES,
+  REACTIVE_STATE_PROPERTY_MATCH_QUERY: () => REACTIVE_STATE_PROPERTY_MATCH_QUERY
+});
+module.exports = __toCommonJS(reactive_state_exports);
+const PROPERTY_STUB = `
+import { Subject, BehaviorSubject, ReplaySubject, AsyncSubject } from 'rxjs';
+import { signal, computed, writableSignal, toSignal } from '@angular/core';
+
+export class RxJSClass {
+  private readonly subject = new Subject<number>();
+  private readonly behaviorSubject = new BehaviorSubject<number>(0);
+  private readonly replaySubject = new ReplaySubject<number>(10);
+  private readonly asyncSubject = new AsyncSubject<number>();
+  private readonly observable = new Observable<number>();
+  private readonly asObservable = this.subject.asObservable();
+}
+
+export class SignalClass {
+  private readonly signal = signal<number>(0);
+  private readonly computed = computed(() => this.counter.value * 2);
+}
+`;
+const REACTIVE_STATE_PROPERTY_MATCH_QUERY = `(p:PropertyDeclaration)-[:HAS_TYPE]->(t:Type)
+    WHERE t.name STARTS WITH 'Subject'
+       OR t.name STARTS WITH 'BehaviorSubject'
+       OR t.name STARTS WITH 'ReplaySubject'
+       OR t.name STARTS WITH 'AsyncSubject'
+       OR t.name STARTS WITH 'WritableSignal'`;
+const REACTIVE_STATE_PROPERTY_EXAMPLES = [
+  {
+    userPrompt: "Find all reactive properties",
+    given: PROPERTY_STUB,
+    when: `MATCH ${REACTIVE_STATE_PROPERTY_MATCH_QUERY}
+    RETURN p, t`,
+    then: [
+      [
+        {
+          labels: ["PropertyDeclaration"],
+          name: "subject"
+        }
+      ],
+      [
+        {
+          labels: ["PropertyDeclaration"],
+          name: "behaviorSubject"
+        }
+      ],
+      [
+        {
+          labels: ["PropertyDeclaration"],
+          name: "replaySubject"
+        }
+      ],
+      [
+        {
+          labels: ["PropertyDeclaration"],
+          name: "asyncSubject"
+        }
+      ],
+      [
+        {
+          labels: ["PropertyDeclaration"],
+          name: "signal"
+        }
+      ]
+    ]
+  }
+];
+const REACTIVE_STATE_PROPERTY_ABSTRACTION = {
+  id: "reactive-state-property",
+  name: "Reactive State Property",
+  schema: {},
+  relationships: {},
+  description: "Abstraction on top of the TypeScript PropertyDeclaration that holds reactive state (primitives, data structures, or custom types). Instantiated and can be set/read reactively",
+  examples: REACTIVE_STATE_PROPERTY_EXAMPLES
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  PROPERTY_STUB,
+  REACTIVE_STATE_PROPERTY_ABSTRACTION,
+  REACTIVE_STATE_PROPERTY_EXAMPLES,
+  REACTIVE_STATE_PROPERTY_MATCH_QUERY
+});

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

@@ -0,0 +1,25 @@
+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 property_declarations_exports = {};
+module.exports = __toCommonJS(property_declarations_exports);
+__reExport(property_declarations_exports, require("./abstractions/reactive-state"), module.exports);
+__reExport(property_declarations_exports, require("./property-declarations.doc"), module.exports);
+__reExport(property_declarations_exports, require("./property-declarations.graph"), module.exports);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ...require("./abstractions/reactive-state"),
+  ...require("./property-declarations.doc"),
+  ...require("./property-declarations.graph")
+});

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

@@ -0,0 +1,74 @@
+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 property_declarations_doc_exports = {};
+__export(property_declarations_doc_exports, {
+  PROPERTY_DECLARATION_DOC: () => PROPERTY_DECLARATION_DOC,
+  PROPERTY_EXAMPLES: () => PROPERTY_EXAMPLES
+});
+module.exports = __toCommonJS(property_declarations_doc_exports);
+var import_core = require("../core/core");
+const STUB = `class Test {
+  num = 1;
+  str = 'test';
+  bool = true;
+}`;
+const PROPERTY_EXAMPLES = [
+  {
+    userPrompt: "Find all property declarations",
+    given: STUB,
+    when: `MATCH (propDecl:PropertyDeclaration) RETURN propDecl`,
+    then: [
+      [
+        {
+          labels: ["PropertyDeclaration"],
+          name: "num"
+        }
+      ],
+      [
+        {
+          labels: ["PropertyDeclaration"],
+          name: "str"
+        }
+      ],
+      [
+        {
+          labels: ["PropertyDeclaration"],
+          name: "bool"
+        }
+      ]
+    ]
+  }
+];
+const PROPERTY_DECLARATION_DOC = {
+  id: "property-declaration",
+  name: "PropertyDeclaration",
+  schema: {
+    ...import_core.NameableSchema,
+    modifiers: "string[]",
+    name: "string",
+    initializerText: "string"
+  },
+  relationships: {},
+  description: `The node represents TypeScript AST kind: PropertyDeclaration.`,
+  examples: PROPERTY_EXAMPLES
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  PROPERTY_DECLARATION_DOC,
+  PROPERTY_EXAMPLES
+});

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

@@ -0,0 +1,43 @@
+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 property_declarations_graph_exports = {};
+__export(property_declarations_graph_exports, {
+  appendClassPropertiesGraph: () => appendClassPropertiesGraph
+});
+module.exports = __toCommonJS(property_declarations_graph_exports);
+var import_class_declarations = require("../class-declarations/class-declarations.doc");
+var import_code = require("../code.graph");
+var import_core = require("../core/core");
+const appendClassPropertiesGraph = (classCodeGraph, classId, classImplementation) => {
+  classImplementation.properties.forEach((p) => {
+    const propertyNode = (0, import_core.extendNameable)(p, {
+      modifiers: p.modifiers,
+      initializerText: p.initializerText
+    });
+    (0, import_code.addNode)(classCodeGraph, propertyNode);
+    (0, import_code.addEdge)(classCodeGraph, {
+      source: classId,
+      target: propertyNode.id,
+      type: import_class_declarations.CLASS_DECLARATION_EDGE_TYPES.HAS_PROPERTY
+    });
+  });
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  appendClassPropertiesGraph
+});

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

@@ -0,0 +1,34 @@
+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 tools_exports = {};
+__export(tools_exports, {
+  TOOLS: () => TOOLS
+});
+module.exports = __toCommonJS(tools_exports);
+var import_match_code_graph = require("./match-code-graph.tool");
+const TOOLS = {
+  matchCodeGraph: import_match_code_graph.matchCodeGraphTool,
+  matchAll: import_match_code_graph.matchAllTool,
+  query: import_match_code_graph.queryTool,
+  queryFromProgram: import_match_code_graph.queryToolFromProgram,
+  queryFromGraph: import_match_code_graph.queryToolFromGraph
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  TOOLS
+});

package/libs/cli/code-graph/src/lib/tools/match-code-graph.tool.js

@@ -0,0 +1,64 @@
+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 match_code_graph_tool_exports = {};
+__export(match_code_graph_tool_exports, {
+  matchAllTool: () => matchAllTool,
+  matchCodeGraphTool: () => matchCodeGraphTool,
+  queryTool: () => queryTool,
+  queryToolFromGraph: () => queryToolFromGraph,
+  queryToolFromProgram: () => queryToolFromProgram
+});
+module.exports = __toCommonJS(match_code_graph_tool_exports);
+var import_cypher = require("@cli/cypher");
+var import_codegular = require("@core/codegular");
+var import_fs = require("fs");
+var import_code_graph = require("../code.graph.factory");
+const matchCodeGraphTool = async (tsConfigPath, query2) => {
+  const program = (0, import_codegular.createProgramFromTsConfig)(tsConfigPath);
+  const codeGraph = (0, import_code_graph.makeCodeGraphFromSourceFiles)(program);
+  const result = (0, import_cypher.matchAll)(query2, codeGraph);
+  return result;
+};
+const queryTool = async (graphPath, queryStatements) => {
+  const codeGraph = JSON.parse((0, import_fs.readFileSync)(graphPath, "utf8"));
+  const result = (0, import_cypher.query)(queryStatements, codeGraph);
+  return result;
+};
+const queryToolFromGraph = async (queryStatements, graph) => {
+  const result = (0, import_cypher.query)(queryStatements, graph);
+  return result;
+};
+const queryToolFromProgram = async (program, queryStatements) => {
+  const codeGraph = (0, import_code_graph.makeCodeGraphFromSourceFiles)(program);
+  const result = (0, import_cypher.query)(queryStatements, codeGraph);
+  return result;
+};
+const matchAllTool = async (query2, tsConfigPath = "./tsconfig.json") => {
+  const program = (0, import_codegular.createProgramFromTsConfig)(tsConfigPath);
+  const codeGraph = (0, import_code_graph.makeCodeGraphFromSourceFiles)(program);
+  const result = (0, import_cypher.matchAll)(query2, codeGraph);
+  return result;
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  matchAllTool,
+  matchCodeGraphTool,
+  queryTool,
+  queryToolFromGraph,
+  queryToolFromProgram
+});

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

@@ -0,0 +1,99 @@
+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 types_exports = {};
+__export(types_exports, {
+  TYPE_DOC: () => TYPE_DOC,
+  TYPE_INFO_EDGE_TYPES: () => TYPE_INFO_EDGE_TYPES,
+  appendTypeInfoGraph: () => appendTypeInfoGraph
+});
+module.exports = __toCommonJS(types_exports);
+var import_typescript = require("@cli/typescript");
+var import_core = require("../core/core");
+var TYPE_INFO_EDGE_TYPES = /* @__PURE__ */ ((TYPE_INFO_EDGE_TYPES2) => {
+  TYPE_INFO_EDGE_TYPES2["HAS_TYPE"] = "HAS_TYPE";
+  TYPE_INFO_EDGE_TYPES2["HAS_BASE_TYPE"] = "HAS_BASE_TYPE";
+  TYPE_INFO_EDGE_TYPES2["HAS_DECLARATION"] = "HAS_DECLARATION";
+  TYPE_INFO_EDGE_TYPES2["HAS_TYPE_ARGUMENT"] = "HAS_TYPE_ARGUMENT";
+  return TYPE_INFO_EDGE_TYPES2;
+})(TYPE_INFO_EDGE_TYPES || {});
+const appendTypeInfoGraph = (classCodeGraph, sourceId, typeInfo) => {
+  if (typeInfo) {
+    const typeInfoId = typeInfo.name;
+    (0, import_typescript.addNode)(classCodeGraph, {
+      id: typeInfoId,
+      labels: [typeInfo.kind],
+      name: typeInfo.name
+    });
+    (0, import_typescript.addEdge)(classCodeGraph, {
+      source: sourceId,
+      target: typeInfoId,
+      type: "HAS_TYPE" /* HAS_TYPE */
+    });
+    if (typeInfo.baseTypes.length > 0) {
+      typeInfo.baseTypes.forEach((baseType) => {
+        appendTypeInfoGraph(classCodeGraph, typeInfoId, baseType);
+      });
+    }
+    if (typeInfo.declaration) {
+      const declarationNode = (0, import_core.extendNameable)(
+        typeInfo.declaration
+      );
+      (0, import_typescript.addNode)(classCodeGraph, declarationNode);
+      (0, import_typescript.addEdge)(classCodeGraph, {
+        source: typeInfoId,
+        target: declarationNode.id,
+        type: "HAS_DECLARATION" /* HAS_DECLARATION */
+      });
+    }
+    if (typeInfo.typeArguments) {
+      typeInfo.typeArguments.forEach((typeArgument) => {
+        appendTypeInfoGraph(classCodeGraph, typeInfoId, typeArgument);
+      });
+    }
+  }
+};
+const TYPE_DOC = {
+  id: "type",
+  name: "Type",
+  schema: {
+    name: "string"
+  },
+  description: `The node represents TypeScript AST kind: Type.`,
+  relationships: {
+    ["HAS_DECLARATION" /* HAS_DECLARATION */]: {
+      examples: [
+        `(t:Type)-[:${"HAS_DECLARATION" /* HAS_DECLARATION */}]->(c:ClassDeclaration)`
+      ]
+    },
+    ["HAS_TYPE_ARGUMENT" /* HAS_TYPE_ARGUMENT */]: {
+      examples: [
+        `(t:Type)-[:${"HAS_TYPE_ARGUMENT" /* HAS_TYPE_ARGUMENT */}]->(t:Type)`
+      ]
+    },
+    ["HAS_BASE_TYPE" /* HAS_BASE_TYPE */]: {
+      examples: [`(t:Type)-[:${"HAS_BASE_TYPE" /* HAS_BASE_TYPE */}]->(t:Type)`]
+    }
+  },
+  examples: []
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  TYPE_DOC,
+  TYPE_INFO_EDGE_TYPES,
+  appendTypeInfoGraph
+});