feat(scanner): extract arrow functions and function expressions (#119)

- Add 'variable' to DocumentType for variable-assigned functions
- Add metadata: isArrowFunction, isHook, isAsync
- Extract arrow functions assigned to const/let variables
- Extract function expressions assigned to variables
- Detect React hooks by 'use*' naming convention
- Extract callees and JSDoc from arrow function bodies
- Add 11 tests covering extraction patterns

Closes #119

Author: prosdev

packages/core/src/scanner/__tests__/fixtures/arrow-functions.ts

@@ -0,0 +1,80 @@
+/**
+ * Test fixtures for arrow function and function expression extraction.
+ * This file contains various patterns that should be extracted by the scanner.
+ */
+
+// Simple arrow function
+const simpleArrow = () => {
+  return 'hello';
+};
+
+// Arrow function with parameters
+const typedArrow = (name: string, age: number): string => {
+  return `${name} is ${age} years old`;
+};
+
+// Exported arrow function
+export const exportedArrow = (value: number) => value * 2;
+
+// Non-exported (private) helper
+const privateHelper = (x: number) => x + 1;
+
+// React-style hook (name starts with 'use')
+export const useCustomHook = (initialValue: string) => {
+  const value = initialValue;
+  const setValue = (newValue: string) => newValue;
+  return { value, setValue };
+};
+
+// Async arrow function
+export const fetchData = async (url: string) => {
+  const response = await fetch(url);
+  return response.json();
+};
+
+// Function expression (legacy style)
+// biome-ignore lint/complexity/useArrowFunction: Testing function expression extraction
+const legacyFunction = function (a: number, b: number) {
+  return a + b;
+};
+
+// Arrow function that calls other functions (for callee extraction)
+const composedFunction = (input: string) => {
+  const trimmed = input.trim();
+  const upper = trimmed.toUpperCase();
+  return privateHelper(upper.length);
+};
+
+/**
+ * A well-documented arrow function.
+ * This should have its JSDoc extracted.
+ */
+const documentedArrow = (param: string) => {
+  return param.toLowerCase();
+};
+
+// These should NOT be extracted (not function-valued):
+// biome-ignore lint/correctness/noUnusedVariables: Test fixtures for non-extraction
+
+// Plain constant (primitive)
+const plainConstant = 42;
+
+// Object constant
+const configObject = {
+  apiUrl: '/api',
+  timeout: 5000,
+};
+
+// Array constant
+const colorList = ['red', 'green', 'blue'];
+
+// Suppress unused warnings - these are test fixtures
+void plainConstant;
+void configObject;
+void colorList;
+
+// String constant
+export const API_ENDPOINT = 'https://api.example.com';
+
+// Re-exported for testing
+export { simpleArrow, typedArrow, composedFunction, documentedArrow, legacyFunction };

packages/core/src/scanner/__tests__/scanner.test.ts

@@ -707,4 +707,170 @@ describe('Scanner', () => {
       expect(calleeNames.some((n) => n.includes('register'))).toBe(true);
     });
   });
+
+  describe('Arrow Function Extraction', () => {
+    // Note: We override exclude to allow fixtures directory (excluded by default)
+    const fixtureExcludes = ['**/node_modules/**', '**/dist/**'];
+
+    it('should extract arrow functions assigned to variables', async () => {
+      const result = await scanRepository({
+        repoRoot,
+        include: ['packages/core/src/scanner/__tests__/fixtures/arrow-functions.ts'],
+        exclude: fixtureExcludes,
+      });
+
+      // Should find arrow function variables
+      const variables = result.documents.filter((d) => d.type === 'variable');
+      expect(variables.length).toBeGreaterThan(0);
+    });
+
+    it('should mark arrow functions with isArrowFunction metadata', async () => {
+      const result = await scanRepository({
+        repoRoot,
+        include: ['packages/core/src/scanner/__tests__/fixtures/arrow-functions.ts'],
+        exclude: fixtureExcludes,
+      });
+
+      const arrowFn = result.documents.find(
+        (d) => d.type === 'variable' && d.metadata.name === 'simpleArrow'
+      );
+      expect(arrowFn).toBeDefined();
+      expect(arrowFn?.metadata.isArrowFunction).toBe(true);
+    });
+
+    it('should detect React hooks by naming convention', async () => {
+      const result = await scanRepository({
+        repoRoot,
+        include: ['packages/core/src/scanner/__tests__/fixtures/arrow-functions.ts'],
+        exclude: fixtureExcludes,
+      });
+
+      const hook = result.documents.find(
+        (d) => d.type === 'variable' && d.metadata.name === 'useCustomHook'
+      );
+      expect(hook).toBeDefined();
+      expect(hook?.metadata.isHook).toBe(true);
+      expect(hook?.metadata.isArrowFunction).toBe(true);
+    });
+
+    it('should detect async arrow functions', async () => {
+      const result = await scanRepository({
+        repoRoot,
+        include: ['packages/core/src/scanner/__tests__/fixtures/arrow-functions.ts'],
+        exclude: fixtureExcludes,
+      });
+
+      const asyncFn = result.documents.find(
+        (d) => d.type === 'variable' && d.metadata.name === 'fetchData'
+      );
+      expect(asyncFn).toBeDefined();
+      expect(asyncFn?.metadata.isAsync).toBe(true);
+    });
+
+    it('should extract exported arrow functions', async () => {
+      const result = await scanRepository({
+        repoRoot,
+        include: ['packages/core/src/scanner/__tests__/fixtures/arrow-functions.ts'],
+        exclude: fixtureExcludes,
+      });
+
+      const exportedFn = result.documents.find(
+        (d) => d.type === 'variable' && d.metadata.name === 'exportedArrow'
+      );
+      expect(exportedFn).toBeDefined();
+      expect(exportedFn?.metadata.exported).toBe(true);
+    });
+
+    it('should extract non-exported arrow functions', async () => {
+      const result = await scanRepository({
+        repoRoot,
+        include: ['packages/core/src/scanner/__tests__/fixtures/arrow-functions.ts'],
+        exclude: fixtureExcludes,
+      });
+
+      const privateFn = result.documents.find(
+        (d) => d.type === 'variable' && d.metadata.name === 'privateHelper'
+      );
+      expect(privateFn).toBeDefined();
+      expect(privateFn?.metadata.exported).toBe(false);
+    });
+
+    it('should extract function expressions assigned to variables', async () => {
+      const result = await scanRepository({
+        repoRoot,
+        include: ['packages/core/src/scanner/__tests__/fixtures/arrow-functions.ts'],
+        exclude: fixtureExcludes,
+      });
+
+      const funcExpr = result.documents.find(
+        (d) => d.type === 'variable' && d.metadata.name === 'legacyFunction'
+      );
+      expect(funcExpr).toBeDefined();
+      expect(funcExpr?.metadata.isArrowFunction).toBe(false);
+    });
+
+    it('should include signature for arrow functions', async () => {
+      const result = await scanRepository({
+        repoRoot,
+        include: ['packages/core/src/scanner/__tests__/fixtures/arrow-functions.ts'],
+        exclude: fixtureExcludes,
+      });
+
+      const fn = result.documents.find(
+        (d) => d.type === 'variable' && d.metadata.name === 'typedArrow'
+      );
+      expect(fn).toBeDefined();
+      expect(fn?.metadata.signature).toContain('typedArrow');
+      expect(fn?.metadata.signature).toContain('=>');
+    });
+
+    it('should extract callees from arrow functions', async () => {
+      const result = await scanRepository({
+        repoRoot,
+        include: ['packages/core/src/scanner/__tests__/fixtures/arrow-functions.ts'],
+        exclude: fixtureExcludes,
+      });
+
+      const fn = result.documents.find(
+        (d) => d.type === 'variable' && d.metadata.name === 'composedFunction'
+      );
+      expect(fn).toBeDefined();
+      expect(fn?.metadata.callees).toBeDefined();
+      expect(fn?.metadata.callees?.length).toBeGreaterThan(0);
+    });
+
+    it('should extract JSDoc from arrow functions', async () => {
+      const result = await scanRepository({
+        repoRoot,
+        include: ['packages/core/src/scanner/__tests__/fixtures/arrow-functions.ts'],
+        exclude: fixtureExcludes,
+      });
+
+      const fn = result.documents.find(
+        (d) => d.type === 'variable' && d.metadata.name === 'documentedArrow'
+      );
+      expect(fn).toBeDefined();
+      expect(fn?.metadata.docstring).toBeDefined();
+      expect(fn?.metadata.docstring).toContain('documented');
+    });
+
+    it('should not extract variables without function initializers', async () => {
+      const result = await scanRepository({
+        repoRoot,
+        include: ['packages/core/src/scanner/__tests__/fixtures/arrow-functions.ts'],
+        exclude: fixtureExcludes,
+      });
+
+      // Should NOT find plain constants
+      const constant = result.documents.find(
+        (d) => d.type === 'variable' && d.metadata.name === 'plainConstant'
+      );
+      expect(constant).toBeUndefined();
+
+      const objectConst = result.documents.find(
+        (d) => d.type === 'variable' && d.metadata.name === 'configObject'
+      );
+      expect(objectConst).toBeUndefined();
+    });
+  });
 });

packages/core/src/scanner/types.ts

@@ -7,7 +7,8 @@ export type DocumentType =
   | 'type'
   | 'struct'
   | 'method'
-  | 'documentation';
+  | 'documentation'
+  | 'variable';
 
 /**
  * Information about a function/method that calls this component
@@ -57,6 +58,11 @@ export interface DocumentMetadata {
   callees?: CalleeInfo[]; // Functions/methods this component calls
   // Note: callers are computed at query time via reverse lookup
 
+  // Variable/function metadata
+  isArrowFunction?: boolean; // True if variable initialized with arrow function
+  isHook?: boolean; // True if name starts with 'use' (React convention)
+  isAsync?: boolean; // True if async function/arrow function
+
   // Extensible for future use
   custom?: Record<string, unknown>;
 }