feat(scanner): extract exported constants with object/array/call initializers

- Extract exported const with object literal initializers (config objects)
- Extract exported const with array literal initializers (static lists)
- Extract exported const with call expression initializers (factories)
- Add metadata: isConstant, constantKind ('object' | 'array' | 'value')
- Skip non-exported constants and primitive exports (low semantic value)
- Add 6 tests for exported constant extraction patterns

This completes Phase 2 of #119.

Author: prosdev

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

@@ -53,27 +53,56 @@ const documentedArrow = (param: string) => {
   return param.toLowerCase();
 };
 
-// These should NOT be extracted (not function-valued):
+// ============================================
+// EXPORTED CONSTANTS - Should be extracted
+// ============================================
+
+/**
+ * API configuration object.
+ * This should be extracted as an exported constant.
+ */
+export const API_CONFIG = {
+  baseUrl: '/api',
+  timeout: 5000,
+  retries: 3,
+};
+
+// Exported array constant
+export const SUPPORTED_LANGUAGES = ['typescript', 'javascript', 'python', 'go'];
+
+// Exported call expression (factory pattern)
+// biome-ignore lint/suspicious/noEmptyBlockStatements: Test fixture
+export const AppContext = (() => ({ value: null }))();
+
+// Typed exported constant
+export const THEME_CONFIG: { dark: boolean; primary: string } = {
+  dark: false,
+  primary: '#007bff',
+};
+
+// ============================================
+// NON-EXPORTED - Should NOT be extracted
+// ============================================
 // biome-ignore lint/correctness/noUnusedVariables: Test fixtures for non-extraction
 
-// Plain constant (primitive)
+// Plain constant (primitive) - never extracted
 const plainConstant = 42;
 
-// Object constant
+// Non-exported object - not extracted (only exported objects are extracted)
 const configObject = {
   apiUrl: '/api',
   timeout: 5000,
 };
 
-// Array constant
+// Non-exported array - not extracted
 const colorList = ['red', 'green', 'blue'];
 
 // Suppress unused warnings - these are test fixtures
 void plainConstant;
 void configObject;
 void colorList;
 
-// String constant
+// Exported primitive - NOT extracted (primitives have low semantic value)
 export const API_ENDPOINT = 'https://api.example.com';
 
 // Re-exported for testing

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

@@ -854,23 +854,127 @@ describe('Scanner', () => {
       expect(fn?.metadata.docstring).toContain('documented');
     });
 
-    it('should not extract variables without function initializers', async () => {
+    it('should not extract non-exported 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
+      // Should NOT find non-exported plain constants
       const constant = result.documents.find(
         (d) => d.type === 'variable' && d.metadata.name === 'plainConstant'
       );
       expect(constant).toBeUndefined();
 
+      // Should NOT find non-exported object constants
       const objectConst = result.documents.find(
         (d) => d.type === 'variable' && d.metadata.name === 'configObject'
       );
       expect(objectConst).toBeUndefined();
+
+      // Should NOT find exported primitive constants (low semantic value)
+      const primitiveExport = result.documents.find(
+        (d) => d.type === 'variable' && d.metadata.name === 'API_ENDPOINT'
+      );
+      expect(primitiveExport).toBeUndefined();
+    });
+  });
+
+  describe('Exported Constant Extraction', () => {
+    // Note: We override exclude to allow fixtures directory (excluded by default)
+    const fixtureExcludes = ['**/node_modules/**', '**/dist/**'];
+
+    it('should extract exported object constants', async () => {
+      const result = await scanRepository({
+        repoRoot,
+        include: ['packages/core/src/scanner/__tests__/fixtures/arrow-functions.ts'],
+        exclude: fixtureExcludes,
+      });
+
+      const config = result.documents.find(
+        (d) => d.type === 'variable' && d.metadata.name === 'API_CONFIG'
+      );
+      expect(config).toBeDefined();
+      expect(config?.metadata.exported).toBe(true);
+      expect(config?.metadata.isConstant).toBe(true);
+      expect(config?.metadata.constantKind).toBe('object');
+    });
+
+    it('should extract exported array constants', async () => {
+      const result = await scanRepository({
+        repoRoot,
+        include: ['packages/core/src/scanner/__tests__/fixtures/arrow-functions.ts'],
+        exclude: fixtureExcludes,
+      });
+
+      const languages = result.documents.find(
+        (d) => d.type === 'variable' && d.metadata.name === 'SUPPORTED_LANGUAGES'
+      );
+      expect(languages).toBeDefined();
+      expect(languages?.metadata.exported).toBe(true);
+      expect(languages?.metadata.isConstant).toBe(true);
+      expect(languages?.metadata.constantKind).toBe('array');
+    });
+
+    it('should extract exported call expression constants (factories)', async () => {
+      const result = await scanRepository({
+        repoRoot,
+        include: ['packages/core/src/scanner/__tests__/fixtures/arrow-functions.ts'],
+        exclude: fixtureExcludes,
+      });
+
+      const context = result.documents.find(
+        (d) => d.type === 'variable' && d.metadata.name === 'AppContext'
+      );
+      expect(context).toBeDefined();
+      expect(context?.metadata.exported).toBe(true);
+      expect(context?.metadata.isConstant).toBe(true);
+      expect(context?.metadata.constantKind).toBe('value');
+    });
+
+    it('should extract typed exported constants with signature', async () => {
+      const result = await scanRepository({
+        repoRoot,
+        include: ['packages/core/src/scanner/__tests__/fixtures/arrow-functions.ts'],
+        exclude: fixtureExcludes,
+      });
+
+      const theme = result.documents.find(
+        (d) => d.type === 'variable' && d.metadata.name === 'THEME_CONFIG'
+      );
+      expect(theme).toBeDefined();
+      expect(theme?.metadata.signature).toContain('THEME_CONFIG');
+      expect(theme?.metadata.signature).toContain('dark');
+    });
+
+    it('should extract JSDoc from exported constants', async () => {
+      const result = await scanRepository({
+        repoRoot,
+        include: ['packages/core/src/scanner/__tests__/fixtures/arrow-functions.ts'],
+        exclude: fixtureExcludes,
+      });
+
+      const config = result.documents.find(
+        (d) => d.type === 'variable' && d.metadata.name === 'API_CONFIG'
+      );
+      expect(config).toBeDefined();
+      expect(config?.metadata.docstring).toBeDefined();
+      expect(config?.metadata.docstring).toContain('API configuration');
+    });
+
+    it('should not extract non-exported object constants', async () => {
+      const result = await scanRepository({
+        repoRoot,
+        include: ['packages/core/src/scanner/__tests__/fixtures/arrow-functions.ts'],
+        exclude: fixtureExcludes,
+      });
+
+      // configObject is not exported, should not be extracted
+      const config = result.documents.find(
+        (d) => d.type === 'variable' && d.metadata.name === 'configObject'
+      );
+      expect(config).toBeUndefined();
     });
   });
 });

packages/core/src/scanner/types.ts

@@ -62,6 +62,8 @@ export interface DocumentMetadata {
   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
+  isConstant?: boolean; // True if exported constant (object/array/call expression)
+  constantKind?: 'object' | 'array' | 'value'; // Kind of constant initializer
 
   // Extensible for future use
   custom?: Record<string, unknown>;

packages/core/src/scanner/typescript.ts

@@ -119,13 +119,15 @@ export class TypeScriptScanner implements Scanner {
       if (doc) documents.push(doc);
     }
 
-    // Extract variables with arrow functions or function expressions
+    // Extract variables with arrow functions, function expressions, or exported constants
     for (const varStmt of sourceFile.getVariableStatements()) {
       for (const decl of varStmt.getDeclarations()) {
         const initializer = decl.getInitializer();
         if (!initializer) continue;
 
         const kind = initializer.getKind();
+
+        // Arrow functions and function expressions (any export status)
         if (kind === SyntaxKind.ArrowFunction || kind === SyntaxKind.FunctionExpression) {
           const doc = this.extractVariableWithFunction(
             decl,
@@ -136,6 +138,16 @@ export class TypeScriptScanner implements Scanner {
           );
           if (doc) documents.push(doc);
         }
+        // Exported constants with object/array/call expression initializers
+        else if (
+          varStmt.isExported() &&
+          (kind === SyntaxKind.ObjectLiteralExpression ||
+            kind === SyntaxKind.ArrayLiteralExpression ||
+            kind === SyntaxKind.CallExpression)
+        ) {
+          const doc = this.extractExportedConstant(decl, varStmt, relativeFile, imports);
+          if (doc) documents.push(doc);
+        }
       }
     }
 
@@ -471,6 +483,74 @@ export class TypeScriptScanner implements Scanner {
     };
   }
 
+  /**
+   * Extract an exported constant with object literal, array literal, or call expression initializer.
+   * Captures configuration objects, contexts, and factory-created values.
+   */
+  private extractExportedConstant(
+    decl: VariableDeclaration,
+    varStmt: VariableStatement,
+    file: string,
+    imports: string[]
+  ): Document | null {
+    const name = decl.getName();
+    if (!name) return null;
+
+    const initializer = decl.getInitializer();
+    if (!initializer) return null;
+
+    const startLine = decl.getStartLineNumber();
+    const endLine = decl.getEndLineNumber();
+    const fullText = decl.getText();
+    const docComment = this.getDocComment(varStmt);
+    const snippet = this.truncateSnippet(fullText);
+
+    // Determine the kind of constant for better embedding text
+    const kind = initializer.getKind();
+    let constantKind: 'object' | 'array' | 'value';
+    if (kind === SyntaxKind.ObjectLiteralExpression) {
+      constantKind = 'object';
+    } else if (kind === SyntaxKind.ArrayLiteralExpression) {
+      constantKind = 'array';
+    } else {
+      constantKind = 'value'; // Call expression or other
+    }
+
+    // Build signature
+    const typeAnnotation = decl.getTypeNode()?.getText();
+    const signature = typeAnnotation
+      ? `export const ${name}: ${typeAnnotation}`
+      : `export const ${name}`;
+
+    const text = this.buildEmbeddingText({
+      type: 'constant',
+      name,
+      signature,
+      docComment,
+      language: 'typescript',
+    });
+
+    return {
+      id: `${file}:${name}:${startLine}`,
+      text,
+      type: 'variable',
+      language: 'typescript',
+      metadata: {
+        file,
+        startLine,
+        endLine,
+        name,
+        signature,
+        exported: true, // Always true for this method
+        docstring: docComment,
+        snippet,
+        imports,
+        isConstant: true,
+        constantKind,
+      },
+    };
+  }
+
   private getDocComment(node: Node): string | undefined {
     // ts-morph doesn't export getJsDocs on base Node type, but it exists on declarations
     const nodeWithJsDocs = node as unknown as {