@codeyam/codeyam-cli 0.1.0-bleeding-edge.8afd3ee

package/analyzer-template/packages/analyze/src/lib/asts/index.ts

@@ -0,0 +1,241 @@
+/**
+ * `lib.asts` is the namespace for functions related to AST manipulation.
+ * Ideally this will wrap most of the TS Compiler API calls. These will be
+ * simple functions that are composed in higher order functions, such as those
+ * that exist within `FileAnalyzer`.
+ */
+
+import ts from 'typescript';
+import * as lib from '../index';
+
+export * as nodes from './nodes/index';
+export * as sourceFiles from './sourceFiles/index';
+
+/**
+ * ## Notes
+ *
+ * The high level flow of the implementation is as follows:
+ *
+ * - get type reference nodes
+ * - map those into type object
+ * - map type objects into symbols (which are import AST constructs)
+ * - map symbols to their declarations
+ * - declarations of symbols of types are, in essence, the type definitions.
+ */
+export function getTypeDependenciesString({
+  sourceFile,
+  program,
+}: {
+  sourceFile: ts.SourceFile;
+  program: ts.Program;
+}) {
+  const typeChecker = program.getTypeChecker();
+  const typeReferenceNodes = getTypeReferenceNodes(sourceFile);
+  const types = typeReferenceNodes.map((trn) =>
+    typeChecker.getTypeAtLocation(trn),
+  );
+  const isSymbol = (x: ts.Symbol | undefined): x is ts.Symbol => !!x;
+  const symbols = types.map((t) => t.aliasSymbol).filter(isSymbol);
+  const isDeclaration = (x: ts.Declaration | undefined): x is ts.Declaration =>
+    !!x;
+  const declarations = symbols
+    .map((s) => s.getDeclarations())
+    .flat()
+    .filter(isDeclaration);
+  const strings = declarations.map((d) => d.getText());
+  const string = strings.join('\n');
+  return string;
+}
+
+/**
+ * This function collects all `TypeReferenceNodes` from the `SourceFile`
+ * (instead of, for example, just the `TypeReferenceNodes` within a particular
+ * `FunctionDeclaration`).
+ */
+export function getTypeReferenceNodes(
+  sourceFile: ts.SourceFile,
+): ts.TypeReferenceNode[] {
+  const typeReferenceNodes: ts.TypeReferenceNode[] = [];
+
+  function visit(node: ts.Node) {
+    if (ts.isTypeReferenceNode(node)) {
+      typeReferenceNodes.push(node);
+    }
+
+    ts.forEachChild(node, visit);
+  }
+
+  visit(sourceFile);
+
+  return typeReferenceNodes;
+}
+
+/**
+ * This function generates the full TS AST from the `tsConfigPath`. In TS
+ * parlance the full AST is called a `Program`. A program consists of individual
+ * source files of type `SourceFile` which contain nodes.
+ *
+ * @param tsConfigPath - Path to the tsconfig.json file
+ * @param excludePatterns - Optional array of regex pattern strings to exclude files from the program
+ */
+export function createProgramFromTsConfigPath(
+  tsConfigPath: string,
+  excludePatterns?: string[],
+): ts.Program {
+  const parsedCommandLine = ts.getParsedCommandLineOfConfigFile(
+    tsConfigPath,
+    {},
+    {
+      ...ts.sys,
+      onUnRecoverableConfigFileDiagnostic: () => {},
+    },
+  );
+
+  if (!parsedCommandLine) {
+    throw new Error('Could not parse tsconfig.json');
+  }
+
+  // Filter file names based on exclude patterns to reduce memory usage
+  let fileNames = parsedCommandLine.fileNames;
+  if (excludePatterns && excludePatterns.length > 0) {
+    const regexPatterns = excludePatterns
+      .map((pattern) => {
+        try {
+          return new RegExp(pattern);
+        } catch (error) {
+          console.warn(`Invalid exclude pattern: ${pattern}`, error);
+          return null;
+        }
+      })
+      .filter((regex): regex is RegExp => regex !== null);
+
+    if (regexPatterns.length > 0) {
+      // Get the project root directory from the tsconfig path
+      const projectRoot = tsConfigPath.substring(
+        0,
+        tsConfigPath.lastIndexOf('/'),
+      );
+
+      const originalCount = fileNames.length;
+      fileNames = fileNames.filter((fileName) => {
+        // Convert absolute path to relative path for pattern matching
+        // This ensures patterns like "tmp" don't match system paths like "/tmp"
+        const relativePath = fileName.startsWith(projectRoot + '/')
+          ? fileName.substring(projectRoot.length + 1)
+          : fileName;
+
+        // Check if file matches any exclude pattern
+        const shouldExclude = regexPatterns.some((regex) =>
+          regex.test(relativePath),
+        );
+        return !shouldExclude;
+      });
+      const excludedCount = originalCount - fileNames.length;
+      if (excludedCount > 0) {
+        // console.log(
+        //   `[TypeScript Program] Excluded ${excludedCount} files based on unapprovedPaths patterns`,
+        // );
+      }
+    }
+  }
+
+  return ts.createProgram({
+    rootNames: fileNames,
+    options: parsedCommandLine.options,
+  });
+}
+
+export function getAllFunctionNodes(
+  sourceFile: ts.SourceFile,
+): lib.types.FunctionNode[] {
+  const functionNodes: lib.types.FunctionNode[] = [];
+
+  function visit(node: ts.Node) {
+    if (lib.asts.nodes.isFunction(node)) {
+      functionNodes.push(node);
+    }
+
+    ts.forEachChild(node, visit);
+  }
+
+  ts.forEachChild(sourceFile, visit);
+
+  return functionNodes;
+}
+
+export function getFirstFunctionsFirstParameterNode(
+  sourceFile: ts.SourceFile,
+): ts.ParameterDeclaration | undefined {
+  const functionNode = lib.asts.getFirstFunctionNode(sourceFile);
+  if (!functionNode) throw 'no functions defined in source file';
+
+  const parameterNode = lib.asts.nodes.getFirstParameter(functionNode);
+  return parameterNode;
+}
+
+/**
+ * Turns an arbitrary string into a `ts.SourceFile` object.
+ *
+ * Example use case is turning the contents of a single file into a
+ * `ts.SourceFile` for analysis.  (In general you should prefer creating a
+ * `ts.Program` so imports can resolve appropriately, but for quick and dirty
+ * single-file analysis, this can suffice.)
+ */
+export function stringToSourceFile(s: string): ts.SourceFile {
+  return ts.createSourceFile(
+    // A dummy file name, as the actual file name is not relevant here
+    'file.ts',
+    s,
+    // You can adjust the script target as necessary
+    // e.g., ts.ScriptTarget.ES2022
+    ts.ScriptTarget.Latest,
+    // setParentNodes: A boolean flag that indicates whether parent references
+    // should be included in the AST nodes
+    true,
+  );
+}
+
+export function getFirstFunctionNode(
+  sf: ts.SourceFile,
+): lib.types.FunctionNode | undefined {
+  let fnode: lib.types.FunctionNode | undefined = undefined;
+
+  function visit(node: ts.Node) {
+    switch (node.kind) {
+      case ts.SyntaxKind.FunctionDeclaration:
+      case ts.SyntaxKind.FunctionExpression:
+      case ts.SyntaxKind.ArrowFunction:
+        if (!lib.asts.nodes.isFunction(node)) {
+          throw 'unsupported function syntax';
+        }
+
+        fnode = node;
+        return;
+      default:
+        if (fnode) return;
+        ts.forEachChild(node, visit);
+    }
+  }
+
+  ts.forEachChild(sf, visit);
+
+  return fnode;
+}
+
+export function getImportDeclarationNodes(
+  sf: ts.SourceFile,
+): ts.ImportDeclaration[] {
+  const imports: ts.ImportDeclaration[] = [];
+
+  function visit(node: ts.Node) {
+    if (ts.isImportDeclaration(node)) {
+      imports.push(node);
+    }
+
+    ts.forEachChild(node, visit);
+  }
+
+  ts.forEachChild(sf, visit);
+
+  return imports;
+}

package/analyzer-template/packages/analyze/src/lib/asts/nodes/getCallExpressionNames.ts

@@ -0,0 +1,37 @@
+import ts from 'typescript';
+
+/**
+ * Returns all `callExpression` names in child nodes
+ */
+export function getCallExpressionNames(node: ts.Node) {
+  const callExpressionNames: any[] = [];
+
+  const visitor = (node: ts.Node) => {
+    if (ts.isCallExpression(node)) {
+      callExpressionNames.push(handleCallExpression(node));
+    } else {
+      node.forEachChild(visitor);
+    }
+  };
+
+  node.forEachChild(visitor);
+
+  return callExpressionNames;
+}
+
+function handleCallExpression(node: ts.Node): string | null {
+  let name: any = null;
+
+  const visitor = (node: ts.Node) => {
+    if (name !== null) return;
+    if (ts.isIdentifier(node)) {
+      name = node.escapedText;
+    } else {
+      node.forEachChild(visitor);
+    }
+  };
+
+  node.forEachChild(visitor);
+
+  return name;
+}

package/analyzer-template/packages/analyze/src/lib/asts/nodes/getFunctionNodeType.ts

@@ -0,0 +1,25 @@
+import ts from 'typescript';
+import { EntityType } from '~codeyam/types';
+import * as lib from '../..';
+
+/**
+ * Returns the node type of the given node
+ */
+export function getFunctionNodeType(
+  node: ts.Node,
+  sourceFile?: ts.SourceFile,
+): EntityType | null {
+  if (lib.asts.nodes.isFunction(node)) {
+    if (lib.asts.nodes.isReactComponent(node)) {
+      return 'visual';
+    }
+
+    if (lib.asts.nodes.isType(node, sourceFile)) {
+      return 'type';
+    }
+
+    return 'library';
+  }
+
+  return null;
+}

package/analyzer-template/packages/analyze/src/lib/asts/nodes/getNodeType.ts

@@ -0,0 +1,130 @@
+import ts from 'typescript';
+
+/**
+ * Returns the node type of the given node
+ */
+export function getNodeType(node: ts.Node, sourceFile: ts.SourceFile) {
+  const syntaxKind = ts.SyntaxKind[node.kind];
+
+  let nodeType: string | undefined;
+  switch (syntaxKind) {
+    case 'CallExpression':
+      nodeType = 'functionCall';
+      break;
+    case 'FunctionDeclaration':
+    case 'FunctionExpression':
+    case 'ArrowFunction':
+      nodeType = 'function';
+      break;
+    case 'ClassDeclaration':
+      nodeType = 'function';
+      break;
+    case 'ExportDeclaration':
+    case 'ExportAssignment':
+      const exportedNode = handleExport(node, sourceFile);
+
+      if (exportedNode.kind === ts.SyntaxKind.ExportDeclaration) {
+        nodeType = 'index';
+      } else {
+        return getNodeType(exportedNode, sourceFile);
+      }
+      break;
+    case 'FirstStatement':
+      const relevantNode = handleFirstStatement(node, sourceFile);
+      return getNodeType(relevantNode, sourceFile);
+    case 'ExportSpecifier':
+      nodeType = 'index';
+      break;
+    case 'FirstLiteralToken':
+    case 'StringLiteral':
+    case 'NumericLiteral':
+    case 'ObjectLiteralExpression':
+      nodeType = 'data';
+      break;
+    case 'TypeAliasDeclaration':
+    case 'InterfaceDeclaration':
+      nodeType = 'type';
+      break;
+    default:
+      // console.log('Unknown node type:', syntaxKind, node.getText(sourceFile));
+      nodeType = 'other';
+  }
+
+  return {
+    nodeType,
+    relevantNode: node,
+  };
+}
+
+function handleExport(node: ts.Node, sourceFile: ts.SourceFile) {
+  const variable = node
+    .getChildren(sourceFile)
+    .find((child) => child.kind === ts.SyntaxKind.Identifier);
+
+  if (!variable) {
+    const variableDeclarationList = node
+      .getChildren(sourceFile)
+      .find((child) => child.kind === ts.SyntaxKind.VariableDeclarationList);
+
+    if (!variableDeclarationList) {
+      if (ts.isExportAssignment(node)) {
+        return node.expression;
+      }
+
+      return node;
+    }
+
+    return handleExport(variableDeclarationList, sourceFile);
+  }
+
+  const findVariableDeclaration = (
+    node: ts.Node,
+    name: string,
+  ): ts.Node | undefined => {
+    if (node.kind === ts.SyntaxKind.VariableDeclaration) {
+      const variableName = node
+        .getChildren(sourceFile)
+        .find((child) => child.kind === ts.SyntaxKind.Identifier);
+      if (variableName?.getText(sourceFile) === name) {
+        const variableAssignment = node
+          .getChildren(sourceFile)
+          .findIndex((child) => child.kind === ts.SyntaxKind.FirstAssignment);
+        return node.getChildren(sourceFile)[variableAssignment + 1];
+      }
+    }
+
+    return node.forEachChild((child) => findVariableDeclaration(child, name));
+  };
+
+  return findVariableDeclaration(sourceFile, variable.getText(sourceFile));
+}
+
+function handleFirstStatement(node: ts.Node, sourceFile: ts.SourceFile) {
+  const findAssignmentContent = (
+    possibleAssignmentNode: ts.Node,
+    nextNode?: ts.Node,
+  ): ts.Node | undefined => {
+    if (
+      nextNode &&
+      possibleAssignmentNode.kind === ts.SyntaxKind.FirstAssignment
+    ) {
+      return nextNode;
+    }
+
+    const children = possibleAssignmentNode.getChildren(sourceFile);
+    for (let i = 0; i < children.length; ++i) {
+      const content = findAssignmentContent(children[i], children[i + 1]);
+      if (content) {
+        return content;
+      }
+    }
+  };
+
+  const firstAssignment = findAssignmentContent(node);
+  if (!firstAssignment) {
+    const children = node.getChildren(sourceFile);
+    return children[1] ?? children[0];
+  }
+
+  return firstAssignment;
+}

package/analyzer-template/packages/analyze/src/lib/asts/nodes/getReactComponentType.ts

@@ -0,0 +1,39 @@
+import ts from 'typescript';
+import * as lib from '../../../lib/index';
+
+export function getReactComponentType(node: ts.Node): lib.types.ComponentType {
+  let hasClassComponent = false;
+  let hasFunctionalComponent = false;
+  let isProvider = false;
+
+  const checkNode = (node: ts.Node): void => {
+    if (ts.isClassDeclaration(node)) {
+      hasClassComponent = true;
+    } else if (
+      ts.isFunctionDeclaration(node) ||
+      ts.isArrowFunction(node) ||
+      ts.isVariableDeclaration(node)
+    ) {
+      hasFunctionalComponent = true;
+    }
+
+    ts.forEachChild(node, checkNode);
+  };
+
+  checkNode(node);
+
+  // TODO: super lazy, this needs to be improved
+  if (node.getText().includes('.Provider')) {
+    isProvider = true;
+  }
+
+  if (isProvider) {
+    return lib.types.ComponentType.Provider;
+  } else if (hasClassComponent) {
+    return lib.types.ComponentType.Class;
+  } else if (hasFunctionalComponent) {
+    return lib.types.ComponentType.Functional;
+  } else {
+    return lib.types.ComponentType.Unknown;
+  }
+}

package/analyzer-template/packages/analyze/src/lib/asts/nodes/index.ts

@@ -0,0 +1,182 @@
+import ts from 'typescript';
+import * as lib from '../../../lib/index';
+
+export { propsNodeToPropsData } from './propsNodeToPropsData';
+export { getReactComponentType } from './getReactComponentType';
+export { getCallExpressionNames } from './getCallExpressionNames';
+export { getNodeType } from './getNodeType';
+export { getFunctionNodeType } from './getFunctionNodeType';
+export { isDefaultExport } from './isDefaultExport';
+
+interface ImportInfo {
+  packageName: string;
+  importedName?: string; // The name as it's exported from the package (e.g., 'original' in 'import { original as alias }')
+  isDefault?: boolean;
+  isNamespace?: boolean;
+}
+
+type ImportMap = Map<string, ImportInfo>;
+
+function extractFunctionCallInfo(node: ts.Node, sourceFile?: ts.SourceFile) {
+  const importMap: ImportMap = new Map();
+
+  // Use provided sourceFile or try to get it from the node
+  const sf = sourceFile || node.getSourceFile();
+
+  // Guard against undefined sourceFile
+  if (!sf) {
+    return {
+      callingVar: undefined,
+      functionName: undefined,
+      packageName: undefined,
+    };
+  }
+
+  sf.statements.forEach((statement) => {
+    if (ts.isImportDeclaration(statement)) {
+      const moduleSpecifier = (statement.moduleSpecifier as ts.StringLiteral)
+        .text;
+
+      if (statement.importClause) {
+        const { name, namedBindings } = statement.importClause;
+
+        // Default import: import MyDefault from 'my-module';
+        if (name) {
+          importMap.set(name.text, {
+            packageName: moduleSpecifier,
+            importedName: 'default', // Or name.text if you prefer to track the original name for default
+            isDefault: true,
+          });
+        }
+
+        // Named imports: import { a, b as c } from 'my-module';
+        if (namedBindings && ts.isNamedImports(namedBindings)) {
+          namedBindings.elements.forEach((specifier) => {
+            const localName = specifier.name.text;
+            const importedName = specifier.propertyName
+              ? specifier.propertyName.text
+              : localName;
+            importMap.set(localName, {
+              packageName: moduleSpecifier,
+              importedName: importedName,
+            });
+          });
+        }
+
+        // Namespace import: import * as MyNamespace from 'my-module';
+        if (namedBindings && ts.isNamespaceImport(namedBindings)) {
+          importMap.set(namedBindings.name.text, {
+            packageName: moduleSpecifier,
+            isNamespace: true,
+            importedName: '*', // Indicate it's a namespace
+          });
+        }
+      }
+    }
+  });
+
+  let callingVar: string | undefined;
+  let functionName: string | undefined;
+
+  if (ts.isCallExpression(node)) {
+    if (ts.isPropertyAccessExpression(node.expression)) {
+      const propAccess = node.expression;
+
+      if (ts.isIdentifier(propAccess.expression)) {
+        callingVar = propAccess.expression.text;
+      }
+      if (ts.isIdentifier(propAccess.name)) {
+        functionName = propAccess.name.text;
+      }
+    }
+  }
+
+  return {
+    callingVar,
+    functionName,
+    packageName: callingVar
+      ? importMap.get(callingVar)?.packageName
+      : undefined,
+  };
+}
+
+export function isReactComponent(node: ts.Node) {
+  const isJsx = (node: ts.Node) =>
+    node.kind === ts.SyntaxKind.JsxElement ||
+    node.kind === ts.SyntaxKind.JsxFragment ||
+    node.kind === ts.SyntaxKind.JsxSelfClosingElement ||
+    node.kind === ts.SyntaxKind.JsxOpeningElement ||
+    node.kind === ts.SyntaxKind.JsxClosingElement;
+
+  return hasChild(node, isJsx);
+}
+
+export function isType(node: ts.Node, sourceFile?: ts.SourceFile) {
+  const info = extractFunctionCallInfo(node, sourceFile);
+
+  if (info.packageName === 'zod' && info.functionName === 'object') {
+    return true;
+  }
+  return false;
+}
+
+export function isExported(node: ts.Node): boolean {
+  let res = false;
+
+  function visit(node: ts.Node) {
+    if (node.kind === ts.SyntaxKind.ExportKeyword) {
+      res = true;
+    }
+  }
+
+  ts.forEachChild(node, visit);
+
+  return res;
+}
+
+/**
+ * Recursively checks each child node of `node` with `test`. If **any**
+ * node passes the test, returns `true`, otherwise `false`.
+ */
+function hasChild(node: ts.Node, test: (node: ts.Node) => boolean): boolean {
+  let bool = false;
+
+  function visit(node: ts.Node) {
+    if (test(node)) {
+      bool = true;
+    }
+
+    ts.forEachChild(node, visit);
+  }
+
+  ts.forEachChild(node, visit);
+  return bool;
+}
+
+/**
+ * Detects if an AST node is a "function node", and type coerces it if so.
+ */
+export function isFunction(
+  node: ts.Node,
+): node is ts.FunctionDeclaration | ts.FunctionExpression | ts.ArrowFunction {
+  return (
+    ts.isFunctionDeclaration(node) ||
+    ts.isFunctionExpression(node) ||
+    ts.isArrowFunction(node) ||
+    ts.isCallExpression(node)
+  );
+}
+
+export function getFirstParameter(
+  fnode: lib.types.FunctionNode,
+): ts.ParameterDeclaration | undefined {
+  const parameters = this.getAllParameters(fnode);
+  if (parameters.length < 1) return;
+  return parameters[0];
+}
+
+export function getAllParameters(
+  fnode: lib.types.FunctionNode,
+): ts.ParameterDeclaration[] | undefined {
+  return fnode.parameters.flatMap((p) => p);
+}