fcis 0.1.0

package/src/extraction/extract-functions.ts

@@ -0,0 +1,570 @@
+/**
+ * AST Function Extraction
+ *
+ * Extracts all function-like nodes from a TypeScript source file into
+ * normalized ExtractedFunction structures. This is part of the SHELL layer
+ * as it interacts with ts-morph AST nodes.
+ *
+ * Handles all function forms:
+ * - FunctionDeclaration
+ * - MethodDeclaration
+ * - ArrowFunction (including those passed as arguments)
+ * - FunctionExpression (including those passed as arguments)
+ * - GetAccessorDeclaration
+ * - SetAccessorDeclaration
+ */
+
+import {
+  type ArrowFunction,
+  type CallExpression,
+  type FunctionDeclaration,
+  type FunctionExpression,
+  type GetAccessorDeclaration,
+  type MethodDeclaration,
+  type Node,
+  type PropertyAccessExpression,
+  type SetAccessorDeclaration,
+  type SourceFile,
+  SyntaxKind,
+} from 'ts-morph'
+
+import type { CallSite, ExtractedFunction, FileImports } from '../types.js'
+
+type FunctionLikeNode =
+  | FunctionDeclaration
+  | MethodDeclaration
+  | ArrowFunction
+  | FunctionExpression
+  | GetAccessorDeclaration
+  | SetAccessorDeclaration
+
+/**
+ * Extract all functions from a source file
+ */
+export function extractFunctions(sourceFile: SourceFile): ExtractedFunction[] {
+  const functions: ExtractedFunction[] = []
+  const filePath = sourceFile.getFilePath()
+  // Track already-added functions by their position to avoid duplicates
+  const addedPositions = new Set<string>()
+
+  const addFunction = (fn: ExtractedFunction) => {
+    const posKey = `${fn.startLine}:${fn.endLine}`
+    if (!addedPositions.has(posKey)) {
+      addedPositions.add(posKey)
+      functions.push(fn)
+    }
+  }
+
+  // Get all function declarations
+  for (const func of sourceFile.getFunctions()) {
+    addFunction(extractFunctionData(func, filePath, 'function'))
+  }
+
+  // Get all class methods, getters, and setters
+  for (const classDecl of sourceFile.getClasses()) {
+    const className = classDecl.getName() ?? null
+
+    for (const method of classDecl.getMethods()) {
+      addFunction(extractFunctionData(method, filePath, 'method', className))
+    }
+
+    for (const getter of classDecl.getGetAccessors()) {
+      addFunction(extractFunctionData(getter, filePath, 'getter', className))
+    }
+
+    for (const setter of classDecl.getSetAccessors()) {
+      addFunction(extractFunctionData(setter, filePath, 'setter', className))
+    }
+  }
+
+  // Get arrow functions and function expressions from variable declarations
+  // These get named after their variable
+  for (const varStatement of sourceFile.getVariableStatements()) {
+    const isExported = varStatement.isExported()
+
+    for (const decl of varStatement.getDeclarations()) {
+      const initializer = decl.getInitializer()
+      const varName = decl.getName()
+
+      if (initializer) {
+        if (initializer.getKind() === SyntaxKind.ArrowFunction) {
+          addFunction(
+            extractFunctionData(
+              initializer as ArrowFunction,
+              filePath,
+              'arrow',
+              varName,
+              isExported,
+            ),
+          )
+        } else if (initializer.getKind() === SyntaxKind.FunctionExpression) {
+          addFunction(
+            extractFunctionData(
+              initializer as FunctionExpression,
+              filePath,
+              'function-expression',
+              varName,
+              isExported,
+            ),
+          )
+        }
+      }
+    }
+  }
+
+  // Also check for exported default arrow functions/function expressions
+  const defaultExport = sourceFile.getDefaultExportSymbol()
+  if (defaultExport) {
+    const declarations = defaultExport.getDeclarations()
+    for (const decl of declarations) {
+      if (decl.getKind() === SyntaxKind.ArrowFunction) {
+        addFunction(
+          extractFunctionData(
+            decl as ArrowFunction,
+            filePath,
+            'arrow',
+            'default',
+            true,
+          ),
+        )
+      } else if (decl.getKind() === SyntaxKind.FunctionExpression) {
+        addFunction(
+          extractFunctionData(
+            decl as FunctionExpression,
+            filePath,
+            'function-expression',
+            'default',
+            true,
+          ),
+        )
+      }
+    }
+  }
+
+  // Extract ALL arrow functions and function expressions in the file,
+  // including those passed as arguments (e.g., tRPC handlers, callbacks, React components)
+  // This catches patterns like: .mutation(async ({ ctx }) => { ... })
+  sourceFile.forEachDescendant(node => {
+    if (node.getKind() === SyntaxKind.ArrowFunction) {
+      const arrowFn = node as ArrowFunction
+      const parentContext = inferParentContext(arrowFn)
+      addFunction(
+        extractFunctionData(arrowFn, filePath, 'arrow', parentContext, false),
+      )
+    } else if (node.getKind() === SyntaxKind.FunctionExpression) {
+      const funcExpr = node as FunctionExpression
+      const parentContext = inferParentContext(funcExpr)
+      addFunction(
+        extractFunctionData(
+          funcExpr,
+          filePath,
+          'function-expression',
+          parentContext,
+          false,
+        ),
+      )
+    }
+  })
+
+  return functions
+}
+
+/**
+ * Infer a meaningful name/context for an arrow function or function expression
+ * based on its position in the AST (e.g., method name it's passed to, property name, etc.)
+ */
+function inferParentContext(
+  node: ArrowFunction | FunctionExpression,
+): string | null {
+  const parent = node.getParent()
+  if (!parent) return null
+
+  // Case 1: Passed as argument to a method call like .mutation(async () => {})
+  // Look for patterns like: .methodName(fn) or methodName(fn)
+  if (parent.getKind() === SyntaxKind.CallExpression) {
+    const callExpr = parent as CallExpression
+    const expression = callExpr.getExpression()
+
+    // Handle property access: obj.method(fn) -> "method"
+    if (expression.getKind() === SyntaxKind.PropertyAccessExpression) {
+      const propAccess = expression as PropertyAccessExpression
+      return propAccess.getName()
+    }
+
+    // Handle direct call: method(fn) -> "method"
+    if (expression.getKind() === SyntaxKind.Identifier) {
+      return expression.getText()
+    }
+  }
+
+  // Case 2: Property assignment like { onClick: () => {} }
+  if (parent.getKind() === SyntaxKind.PropertyAssignment) {
+    const propAssignment = parent as import('ts-morph').PropertyAssignment
+    return propAssignment.getName()
+  }
+
+  // Case 3: Short-hand property like { onClick }
+  if (parent.getKind() === SyntaxKind.ShorthandPropertyAssignment) {
+    const shorthand = parent as import('ts-morph').ShorthandPropertyAssignment
+    return shorthand.getName()
+  }
+
+  return null
+}
+
+/**
+ * Extract data from a function-like node
+ */
+function extractFunctionData(
+  node: FunctionLikeNode,
+  filePath: string,
+  kind: ExtractedFunction['kind'],
+  parentContext: string | null = null,
+  isExportedOverride?: boolean,
+): ExtractedFunction {
+  const startLine = node.getStartLineNumber()
+  const endLine = node.getEndLineNumber()
+  const bodyLineCount = endLine - startLine + 1
+
+  // Get function name
+  let name: string | null = null
+  if ('getName' in node && typeof node.getName === 'function') {
+    name = node.getName() ?? null
+  }
+
+  // For arrow functions and function expressions assigned to variables,
+  // use the variable name as the function name if no intrinsic name exists
+  if (name === null && parentContext !== null) {
+    name = parentContext
+  }
+
+  // Check if async
+  const isAsync = 'isAsync' in node ? (node.isAsync?.() ?? false) : false
+
+  // Check if exported
+  let isExported = isExportedOverride ?? false
+  if (!isExported && 'isExported' in node) {
+    isExported = (node as FunctionDeclaration).isExported?.() ?? false
+  }
+
+  // Get body for analysis
+  const body = getBodyNode(node)
+
+  // Count statements
+  const statementCount = countStatements(body)
+
+  // Check for conditionals
+  const hasConditionals = checkForConditionals(body)
+
+  // Extract call sites
+  const callSites = extractCallSites(node, startLine)
+
+  // Check if any call is awaited
+  const hasAwait = callSites.some(cs => cs.isAwaited) || checkForAwait(node)
+
+  // Extract property access chains
+  const propertyAccessChains = extractPropertyAccessChains(node)
+
+  return {
+    name,
+    filePath,
+    startLine,
+    endLine,
+    isAsync,
+    isExported,
+    bodyLineCount,
+    statementCount,
+    hasConditionals,
+    parentContext,
+    callSites,
+    hasAwait,
+    propertyAccessChains,
+    kind,
+  }
+}
+
+/**
+ * Get the body node of a function-like node
+ */
+function getBodyNode(node: FunctionLikeNode): Node | undefined {
+  if ('getBody' in node) {
+    return node.getBody()
+  }
+  return undefined
+}
+
+/**
+ * Count statements in a function body
+ */
+function countStatements(body: Node | undefined): number {
+  if (!body) return 0
+
+  // If it's a block, count statements
+  if (body.getKind() === SyntaxKind.Block) {
+    const statements = body.getChildrenOfKind(SyntaxKind.SyntaxList)
+    if (statements.length > 0 && statements[0]) {
+      return statements[0].getChildren().filter(isStatement).length
+    }
+  }
+
+  // If it's an expression body (arrow function), count as 1
+  return 1
+}
+
+/**
+ * Check if a node is a statement
+ */
+function isStatement(node: Node): boolean {
+  const kind = node.getKind()
+  return (
+    kind === SyntaxKind.VariableStatement ||
+    kind === SyntaxKind.ExpressionStatement ||
+    kind === SyntaxKind.ReturnStatement ||
+    kind === SyntaxKind.IfStatement ||
+    kind === SyntaxKind.ForStatement ||
+    kind === SyntaxKind.ForInStatement ||
+    kind === SyntaxKind.ForOfStatement ||
+    kind === SyntaxKind.WhileStatement ||
+    kind === SyntaxKind.DoStatement ||
+    kind === SyntaxKind.SwitchStatement ||
+    kind === SyntaxKind.TryStatement ||
+    kind === SyntaxKind.ThrowStatement ||
+    kind === SyntaxKind.BreakStatement ||
+    kind === SyntaxKind.ContinueStatement
+  )
+}
+
+/**
+ * Check if a function body contains conditionals
+ */
+function checkForConditionals(body: Node | undefined): boolean {
+  if (!body) return false
+
+  let hasConditionals = false
+
+  body.forEachDescendant(node => {
+    const kind = node.getKind()
+    if (
+      kind === SyntaxKind.IfStatement ||
+      kind === SyntaxKind.ConditionalExpression ||
+      kind === SyntaxKind.SwitchStatement
+    ) {
+      hasConditionals = true
+    }
+  })
+
+  return hasConditionals
+}
+
+/**
+ * Check if a function contains await expressions
+ */
+function checkForAwait(node: FunctionLikeNode): boolean {
+  let hasAwait = false
+
+  node.forEachDescendant((descendant, traversal) => {
+    // Don't descend into nested functions
+    const kind = descendant.getKind()
+    if (
+      kind === SyntaxKind.FunctionDeclaration ||
+      kind === SyntaxKind.FunctionExpression ||
+      kind === SyntaxKind.ArrowFunction ||
+      kind === SyntaxKind.MethodDeclaration
+    ) {
+      traversal.skip()
+      return
+    }
+
+    if (kind === SyntaxKind.AwaitExpression) {
+      hasAwait = true
+    }
+  })
+
+  return hasAwait
+}
+
+/**
+ * Extract call sites from a function
+ */
+function extractCallSites(
+  node: FunctionLikeNode,
+  functionStartLine: number,
+): CallSite[] {
+  const callSites: CallSite[] = []
+
+  node.forEachDescendant((descendant, traversal) => {
+    // Don't descend into nested functions
+    const kind = descendant.getKind()
+    if (
+      kind === SyntaxKind.FunctionDeclaration ||
+      kind === SyntaxKind.FunctionExpression ||
+      kind === SyntaxKind.ArrowFunction ||
+      kind === SyntaxKind.MethodDeclaration
+    ) {
+      traversal.skip()
+      return
+    }
+
+    if (kind === SyntaxKind.CallExpression) {
+      const callExpr = descendant as CallExpression
+      const expression = getCallExpressionText(callExpr)
+      const line = callExpr.getStartLineNumber() - functionStartLine
+
+      // Check if this call is awaited
+      const parent = callExpr.getParent()
+      const isAwaited = parent?.getKind() === SyntaxKind.AwaitExpression
+
+      callSites.push({
+        expression,
+        line,
+        isAwaited,
+      })
+    }
+  })
+
+  return callSites
+}
+
+/**
+ * Get the text representation of a call expression
+ */
+function getCallExpressionText(callExpr: CallExpression): string {
+  const expression = callExpr.getExpression()
+
+  // Handle property access chains like db.user.findFirst
+  if (expression.getKind() === SyntaxKind.PropertyAccessExpression) {
+    return getPropertyAccessChainText(expression as PropertyAccessExpression)
+  }
+
+  // Handle simple function calls
+  return expression.getText()
+}
+
+/**
+ * Get the full text of a property access chain
+ */
+function getPropertyAccessChainText(node: PropertyAccessExpression): string {
+  const parts: string[] = []
+  let current: Node = node
+
+  while (current.getKind() === SyntaxKind.PropertyAccessExpression) {
+    const propAccess = current as PropertyAccessExpression
+    parts.unshift(propAccess.getName())
+    current = propAccess.getExpression()
+  }
+
+  // Add the base expression
+  parts.unshift(current.getText())
+
+  return parts.join('.')
+}
+
+/**
+ * Extract property access chains from a function
+ */
+function extractPropertyAccessChains(node: FunctionLikeNode): string[] {
+  const chains = new Set<string>()
+
+  node.forEachDescendant((descendant, traversal) => {
+    // Don't descend into nested functions
+    const kind = descendant.getKind()
+    if (
+      kind === SyntaxKind.FunctionDeclaration ||
+      kind === SyntaxKind.FunctionExpression ||
+      kind === SyntaxKind.ArrowFunction ||
+      kind === SyntaxKind.MethodDeclaration
+    ) {
+      traversal.skip()
+      return
+    }
+
+    if (kind === SyntaxKind.PropertyAccessExpression) {
+      const propAccess = descendant as PropertyAccessExpression
+      // Only get top-level property access chains (not nested ones)
+      const parent = propAccess.getParent()
+      if (parent?.getKind() !== SyntaxKind.PropertyAccessExpression) {
+        const chain = getPropertyAccessChainText(propAccess)
+        // Filter out simple single-level access
+        if (chain.includes('.')) {
+          chains.add(chain)
+        }
+      }
+    }
+  })
+
+  return Array.from(chains)
+}
+
+/**
+ * Extract imports from a source file
+ */
+export function extractImports(sourceFile: SourceFile): FileImports {
+  const filePath = sourceFile.getFilePath()
+  const imports: FileImports['imports'] = []
+
+  for (const importDecl of sourceFile.getImportDeclarations()) {
+    const moduleSpecifier = importDecl.getModuleSpecifierValue()
+    const namedImports: string[] = []
+
+    // Get named imports
+    for (const namedImport of importDecl.getNamedImports()) {
+      namedImports.push(namedImport.getName())
+    }
+
+    // Get default import
+    const defaultImport = importDecl.getDefaultImport()
+    if (defaultImport) {
+      namedImports.push(defaultImport.getText())
+    }
+
+    // Get namespace import
+    const namespaceImport = importDecl.getNamespaceImport()
+    if (namespaceImport) {
+      namedImports.push(namespaceImport.getText())
+    }
+
+    imports.push({
+      moduleSpecifier,
+      namedImports,
+    })
+  }
+
+  return {
+    filePath,
+    imports,
+  }
+}
+
+/**
+ * Check if a file is type-only (contains only types, interfaces, enums, no function bodies)
+ */
+export function isTypeOnlyFile(sourceFile: SourceFile): boolean {
+  // Check for function declarations
+  if (sourceFile.getFunctions().length > 0) return false
+
+  // Check for classes with methods
+  for (const classDecl of sourceFile.getClasses()) {
+    if (classDecl.getMethods().length > 0) return false
+    if (classDecl.getGetAccessors().length > 0) return false
+    if (classDecl.getSetAccessors().length > 0) return false
+  }
+
+  // Check for variable declarations with functions
+  for (const varStatement of sourceFile.getVariableStatements()) {
+    for (const decl of varStatement.getDeclarations()) {
+      const initializer = decl.getInitializer()
+      if (initializer) {
+        const kind = initializer.getKind()
+        if (
+          kind === SyntaxKind.ArrowFunction ||
+          kind === SyntaxKind.FunctionExpression
+        ) {
+          return false
+        }
+      }
+    }
+  }
+
+  // If we got here, file has no function bodies
+  return true
+}