@memberjunction/query-gen 6.1.4 → 6.2.0-edge.1

package/src/cli/commands/generate.ts

@@ -13,8 +13,8 @@
 import ora from 'ora';
 import chalk from 'chalk';
 import { Metadata, DatabaseProviderBase, EntityInfo, LogStatus } from '@memberjunction/core';
-import { loadConfig } from '../config';
-import { getSystemUser } from '../../utils/user-helpers';
+import { LoadConfig } from '../config';
+import { GetSystemUser } from '../../utils/user-helpers';
 import { EntityGrouper } from '../../core/EntityGrouper';
 import { QuestionGenerator } from '../../core/QuestionGenerator';
 import { QueryWriter } from '../../core/QueryWriter';
@@ -24,9 +24,9 @@ import { MetadataExporter } from '../../core/MetadataExporter';
 import { QueryDatabaseWriter } from '../../core/QueryDatabaseWriter';
 import { EmbeddingService } from '../../vectors/EmbeddingService';
 import { SimilaritySearch } from '../../vectors/SimilaritySearch';
-import { formatEntityMetadataForPrompt } from '../../utils/entity-helpers';
-import { extractErrorMessage } from '../../utils/error-handlers';
-import { buildQueryCategory, extractUniqueCategories } from '../../utils/category-builder';
+import { FormatEntityMetadataForPrompt } from '../../utils/entity-helpers';
+import { ExtractErrorMessage } from '../../utils/error-handlers';
+import { BuildQueryCategory, ExtractUniqueCategories } from '../../utils/category-builder';
 import { ValidatedQuery, GoldenQuery, EntityGroup, QueryCategoryInfo } from '../../data/schema';
 import { readFileSync } from 'fs';
 import { dirname, join } from 'path';
@@ -38,13 +38,13 @@ import { fileURLToPath } from 'url';
  * Full orchestration of query generation workflow with progress reporting.
  * Uses ora for spinners and chalk for colored output.
  */
-export async function generateCommand(options: Record<string, unknown>): Promise<void> {
+export async function GenerateCommand(options: Record<string, unknown>): Promise<void> {
   const spinner = ora('Initializing query generation...').start();
 
   try {
     // 1. Load configuration
     spinner.text = 'Loading configuration...';
-    const config = loadConfig(options);
+    const config = LoadConfig(options);
 
     // Show model/vendor overrides if configured
     if (config.modelOverride || config.vendorOverride) {
@@ -60,7 +60,7 @@ export async function generateCommand(options: Record<string, unknown>): Promise
     }
 
     // 2. Get system user from UserCache (populated by provider initialization)
-    const contextUser = getSystemUser();
+    const contextUser = GetSystemUser();
 
     // 3. Verify database connection and metadata
     spinner.text = 'Loading metadata...';
@@ -150,11 +150,11 @@ export async function generateCommand(options: Record<string, unknown>): Promise
     spinner.start('Building category structure...');
     const categoryMap = new Map<string, QueryCategoryInfo>();
     for (const group of entityGroups) {
-      const category = buildQueryCategory(config, group);
+      const category = BuildQueryCategory(config, group);
       // Use primary entity name as key for lookup during query generation
       categoryMap.set(group.primaryEntity.Name, category);
     }
-    const uniqueCategories = extractUniqueCategories(Array.from(categoryMap.values()));
+    const uniqueCategories = ExtractUniqueCategories(Array.from(categoryMap.values()));
     spinner.succeed(chalk.green(`Created ${uniqueCategories.length} ${uniqueCategories.length === 1 ? 'category' : 'categories'}`));
 
     // 6. Generate queries for each entity group
@@ -202,14 +202,14 @@ export async function generateCommand(options: Record<string, unknown>): Promise
           const queryWriter = new QueryWriter(contextUser, config);
           const generatedQuery = await queryWriter.generateQuery(
             question,
-            group.entities.map((e: EntityInfo) => formatEntityMetadataForPrompt(e, group.entities)),
+            group.entities.map((e: EntityInfo) => FormatEntityMetadataForPrompt(e, group.entities)),
             fewShotExamples
           );
 
           // Test and fix query
           // Access the database provider through Metadata.Provider
           const dataProvider = Metadata.Provider as DatabaseProviderBase; // global-provider-ok: CLI tool, single-provider context
-          const entityMetadata = group.entities.map((e: EntityInfo) => formatEntityMetadataForPrompt(e, group.entities));
+          const entityMetadata = group.entities.map((e: EntityInfo) => FormatEntityMetadataForPrompt(e, group.entities));
           const queryTester = new QueryTester(
             dataProvider,
             entityMetadata,
@@ -277,7 +277,7 @@ export async function generateCommand(options: Record<string, unknown>): Promise
 
         spinner.warn(
           chalk.yellow(
-            `${groupPrefix} Error processing ${entityDisplay}: ${extractErrorMessage(error, 'Query Generation')}`
+            `${groupPrefix} Error processing ${entityDisplay}: ${ExtractErrorMessage(error, 'Query Generation')}`
           )
         );
       }
@@ -313,11 +313,16 @@ export async function generateCommand(options: Record<string, unknown>): Promise
 
   } catch (error: unknown) {
     spinner.fail(chalk.red('Query generation failed'));
-    console.error(chalk.red(extractErrorMessage(error, 'Query Generation')));
+    console.error(chalk.red(ExtractErrorMessage(error, 'Query Generation')));
     process.exit(1);
   }
 }
 
+/** @deprecated Use {@link GenerateCommand}. */
+export async function generateCommand(options: Record<string, unknown>): Promise<void> {
+  return GenerateCommand(options);
+}
+
 /**
  * Load golden queries from compile-time imported JSON data
  *
@@ -353,7 +358,7 @@ async function loadGoldenQueries(config: { verbose: boolean }): Promise<GoldenQu
     return goldenQueries;
   } catch (error: unknown) {
     if (config.verbose) {
-      LogStatus(`[Warning] Failed to load golden queries: ${extractErrorMessage(error, 'loadGoldenQueries')}`);
+      LogStatus(`[Warning] Failed to load golden queries: ${ExtractErrorMessage(error, 'loadGoldenQueries')}`);
     }
     return [];
   }

package/src/cli/commands/validate.ts

@@ -13,11 +13,11 @@ import chalk from 'chalk';
 import * as fs from 'fs';
 import * as path from 'path';
 import { Metadata, DatabaseProviderBase } from '@memberjunction/core';
-import { getSystemUser } from '../../utils/user-helpers';
+import { GetSystemUser } from '../../utils/user-helpers';
 import { QueryTester } from '../../core/QueryTester';
-import { extractErrorMessage } from '../../utils/error-handlers';
+import { ExtractErrorMessage } from '../../utils/error-handlers';
 import { GeneratedQuery, QueryMetadataRecord } from '../../data/schema';
-import { loadConfig } from '../config';
+import { LoadConfig } from '../config';
 
 /**
  * Execute the validate command
@@ -25,7 +25,7 @@ import { loadConfig } from '../config';
  * Loads query metadata files and validates each query template.
  * Reports success/failure statistics.
  */
-export async function validateCommand(options: Record<string, unknown>): Promise<void> {
+export async function ValidateCommand(options: Record<string, unknown>): Promise<void> {
   const spinner = ora('Initializing validation...').start();
 
   try {
@@ -33,10 +33,10 @@ export async function validateCommand(options: Record<string, unknown>): Promise
     const verbose = Boolean(options.verbose);
 
     // Load configuration
-    const config = loadConfig(options);
+    const config = LoadConfig(options);
 
     // 1. Get system user from UserCache (populated by provider initialization)
-    const contextUser = getSystemUser();
+    const contextUser = GetSystemUser();
 
     // 2. Verify database connection and load metadata
     spinner.text = 'Loading metadata...';
@@ -98,7 +98,7 @@ export async function validateCommand(options: Record<string, unknown>): Promise
           }
         } catch (error: unknown) {
           failCount++;
-          const errorMsg = extractErrorMessage(error, 'Query Validation');
+          const errorMsg = ExtractErrorMessage(error, 'Query Validation');
           errors.push({ file, error: `${queryRecord.fields.Name}: ${errorMsg}` });
           if (verbose) {
             spinner.warn(`${filePrefix} ${chalk.red('✗')} ${queryRecord.fields.Name}: ${errorMsg}`);
@@ -137,11 +137,16 @@ export async function validateCommand(options: Record<string, unknown>): Promise
 
   } catch (error: unknown) {
     spinner.fail(chalk.red('Validation failed'));
-    console.error(chalk.red(extractErrorMessage(error, 'Query Validation')));
+    console.error(chalk.red(ExtractErrorMessage(error, 'Query Validation')));
     process.exit(1);
   }
 }
 
+/** @deprecated Use {@link ValidateCommand}. */
+export async function validateCommand(options: Record<string, unknown>): Promise<void> {
+  return ValidateCommand(options);
+}
+
 /**
  * Load all query metadata files from the specified directory
  */

package/src/cli/config.ts

@@ -116,7 +116,7 @@ const DEFAULT_CONFIG: QueryGenConfig = {
  * @param cliOptions - Options provided via command line
  * @returns Merged configuration ready for use
  */
-export function loadConfig(cliOptions: Record<string, unknown>): QueryGenConfig {
+export function LoadConfig(cliOptions: Record<string, unknown>): QueryGenConfig {
   // Start with defaults
   const config: QueryGenConfig = { ...DEFAULT_CONFIG };
 
@@ -173,6 +173,11 @@ export function loadConfig(cliOptions: Record<string, unknown>): QueryGenConfig
   return config;
 }
 
+/** @deprecated Use {@link LoadConfig}. */
+export function loadConfig(cliOptions: Record<string, unknown>): QueryGenConfig {
+  return LoadConfig(cliOptions);
+}
+
 /**
  * Load mj.config.cjs from current working directory
  * Returns null if file doesn't exist or can't be loaded

package/src/cli/index.ts

@@ -12,9 +12,9 @@
 
 import { Command } from 'commander';
 import { createRequire } from 'node:module';
-import { generateCommand } from './commands/generate';
-import { validateCommand } from './commands/validate';
-import { exportCommand } from './commands/export';
+import { GenerateCommand } from './commands/generate';
+import { ValidateCommand } from './commands/validate';
+import { ExportCommand } from './commands/export';
 
 // Use createRequire to import JSON (compatible with ESM)
 const require = createRequire(import.meta.url);
@@ -41,21 +41,21 @@ program
   .option('-o, --output <path>', 'Output directory')
   .option('--mode <mode>', 'Output mode: metadata|database|both')
   .option('-v, --verbose', 'Verbose output')
-  .action(generateCommand);
+  .action(GenerateCommand);
 
 program
   .command('validate')
   .description('Validate existing query templates')
   .option('-p, --path <path>', 'Path to queries metadata file', './metadata/queries')
   .option('-v, --verbose', 'Verbose output')
-  .action(validateCommand);
+  .action(ValidateCommand);
 
 program
   .command('export')
   .description('Export queries from database to metadata files')
   .option('-o, --output <path>', 'Output directory')
   .option('-v, --verbose', 'Verbose output')
-  .action(exportCommand);
+  .action(ExportCommand);
 
 // Parse command line arguments
 program.parse();

package/src/core/EntityGrouper.ts

@@ -10,9 +10,9 @@ import { EntityInfo, EntityRelationshipInfo, UserInfo, LogStatus } from '@member
 import { AIEngine } from '@memberjunction/aiengine';
 import { EntityGroup } from '../data/schema';
 import { QueryGenConfig } from '../cli/config';
-import { generateRelationshipGraph, formatEntitiesForPrompt } from '../utils/graph-helpers';
-import { extractErrorMessage } from '../utils/error-handlers';
-import { executePromptWithOverrides } from '../utils/prompt-helpers';
+import { GenerateRelationshipGraph, FormatEntitiesForPrompt } from '../utils/graph-helpers';
+import { ExtractErrorMessage } from '../utils/error-handlers';
+import { ExecutePromptWithOverrides } from '../utils/prompt-helpers';
 
 /**
  * LLM response format from Entity Group Generator prompt
@@ -54,7 +54,7 @@ export class EntityGrouper {
    * @param contextUser - User context for server-side operations
    * @returns Array of validated entity groups with business context
    */
-  async generateEntityGroups(
+  async GenerateEntityGroups(
     entities: EntityInfo[],
     contextUser: UserInfo
   ): Promise<EntityGroup[]> {
@@ -109,10 +109,18 @@ export class EntityGrouper {
 
       return deduplicatedGroups;
     } catch (error: unknown) {
-      throw new Error(extractErrorMessage(error, 'EntityGrouper.generateEntityGroups'));
+      throw new Error(ExtractErrorMessage(error, 'EntityGrouper.generateEntityGroups'));
     }
   }
 
+  /** @deprecated Use {@link GenerateEntityGroups}. */
+  async generateEntityGroups(
+    entities: EntityInfo[],
+    contextUser: UserInfo
+  ): Promise<EntityGroup[]> {
+    return this.GenerateEntityGroups(entities, contextUser);
+  }
+
   /**
    * Group entities by schema name
    */
@@ -139,8 +147,8 @@ export class EntityGrouper {
    * @param schemaName - Name of the schema being processed
    */
   private prepareSchemaData(entities: EntityInfo[], schemaName: string): Record<string, unknown> {
-    const formattedEntities = formatEntitiesForPrompt(entities);
-    const relationshipGraph = generateRelationshipGraph(entities);
+    const formattedEntities = FormatEntitiesForPrompt(entities);
+    const relationshipGraph = GenerateRelationshipGraph(entities);
 
     // Calculate target group count using graph theory metrics
     // This approach uses actual schema connectivity instead of arbitrary thresholds
@@ -217,7 +225,7 @@ export class EntityGrouper {
     }
 
     // Execute with model/vendor overrides if specified in config
-    const result = await executePromptWithOverrides<LLMEntityGroupResponse>(
+    const result = await ExecutePromptWithOverrides<LLMEntityGroupResponse>(
       prompt,
       schemaData,
       contextUser,
@@ -329,7 +337,7 @@ export class EntityGrouper {
         }
       } catch (error: unknown) {
         if (this.config.verbose) {
-          LogStatus(`  ✗ Group validation error: ${extractErrorMessage(error, 'Group Validation')}`);
+          LogStatus(`  ✗ Group validation error: ${ExtractErrorMessage(error, 'Group Validation')}`);
         }
       }
     }

package/src/core/MetadataExporter.ts

@@ -29,7 +29,7 @@ export class MetadataExporter {
    * @param config - QueryGen configuration
    * @returns Export result with file path and query count
    */
-  async exportQueries(
+  async ExportQueries(
     validatedQueries: ValidatedQuery[],
     uniqueCategories: QueryCategoryInfo[],
     config: QueryGenConfig
@@ -87,6 +87,15 @@ export class MetadataExporter {
     };
   }
 
+  /** @deprecated Use {@link ExportQueries}. */
+  async exportQueries(
+    validatedQueries: ValidatedQuery[],
+    uniqueCategories: QueryCategoryInfo[],
+    config: QueryGenConfig
+  ): Promise<ExportResult> {
+    return this.ExportQueries(validatedQueries, uniqueCategories, config);
+  }
+
   /**
    * Transform a validated query into MJ metadata format
    *

package/src/core/QueryDatabaseWriter.ts

@@ -13,7 +13,7 @@ import {
   QueryEngine
 } from '@memberjunction/core-entities';
 import { ValidatedQuery, WriteResult } from '../data/schema';
-import { extractErrorMessage } from '../utils/error-handlers';
+import { ExtractErrorMessage } from '../utils/error-handlers';
 
 /**
  * QueryDatabaseWriter class
@@ -40,7 +40,7 @@ export class QueryDatabaseWriter {
    * @param contextUser - User context for entity operations
    * @returns Write result with success status and per-query results
    */
-  async writeQueriesToDatabase(
+  async WriteQueriesToDatabase(
     validatedQueries: ValidatedQuery[],
     contextUser: UserInfo
   ): Promise<WriteResult> {
@@ -79,7 +79,7 @@ export class QueryDatabaseWriter {
       return { success: true, results };
     } catch (error: unknown) {
       await provider.RollbackTransaction();
-      const message = extractErrorMessage(error, 'Database Write');
+      const message = ExtractErrorMessage(error, 'Database Write');
       return {
         success: false,
         results: [`✗ Batch rolled back: ${message}`, ...results.map(r => r.replace('✓', '~'))]
@@ -87,6 +87,14 @@ export class QueryDatabaseWriter {
     }
   }
 
+  /** @deprecated Use {@link WriteQueriesToDatabase}. */
+  async writeQueriesToDatabase(
+    validatedQueries: ValidatedQuery[],
+    contextUser: UserInfo
+  ): Promise<WriteResult> {
+    return this.WriteQueriesToDatabase(validatedQueries, contextUser);
+  }
+
   /**
    * Get or create category ID from QueryCategoryInfo
    * Uses caching to avoid repeated lookups/creations

package/src/core/QueryFixer.ts

@@ -8,7 +8,7 @@
 import { AIEngine } from '@memberjunction/aiengine';
 import { MJAIPromptEntityExtended } from '@memberjunction/ai-core-plus';
 import { UserInfo, LogStatus } from '@memberjunction/core';
-import { extractErrorMessage } from '../utils/error-handlers';
+import { ExtractErrorMessage } from '../utils/error-handlers';
 import {
   GeneratedQuery,
   EntityMetadataForPrompt,
@@ -16,7 +16,7 @@ import {
 } from '../data/schema';
 import { PROMPT_SQL_QUERY_FIXER } from '../prompts/PromptNames';
 import { QueryGenConfig } from '../cli/config';
-import { executePromptWithOverrides } from '../utils/prompt-helpers';
+import { ExecutePromptWithOverrides } from '../utils/prompt-helpers';
 
 /**
  * QueryFixer class
@@ -38,7 +38,7 @@ export class QueryFixer {
    * @param businessQuestion - Original business question for context
    * @returns Corrected SQL query with updated metadata
    */
-  async fixQuery(
+  async FixQuery(
     query: GeneratedQuery,
     errorMessage: string,
     entityMetadata: EntityMetadataForPrompt[],
@@ -71,10 +71,20 @@ export class QueryFixer {
 
       return fixedQuery;
     } catch (error: unknown) {
-      throw new Error(extractErrorMessage(error, 'QueryFixer.fixQuery'));
+      throw new Error(ExtractErrorMessage(error, 'QueryFixer.fixQuery'));
     }
   }
 
+  /** @deprecated Use {@link FixQuery}. */
+  async fixQuery(
+    query: GeneratedQuery,
+    errorMessage: string,
+    entityMetadata: EntityMetadataForPrompt[],
+    businessQuestion: BusinessQuestion
+  ): Promise<GeneratedQuery> {
+    return this.FixQuery(query, errorMessage, entityMetadata, businessQuestion);
+  }
+
   /**
    * Find prompt by name in AIEngine cache
    * Throws if prompt not found
@@ -107,7 +117,7 @@ export class QueryFixer {
     }
   ): Promise<GeneratedQuery> {
     // The SQL Query Fixer template returns { newSQL, reasoning }
-    const result = await executePromptWithOverrides<{
+    const result = await ExecutePromptWithOverrides<{
       newSQL: string;
       reasoning: string;
     }>(prompt, promptData, this.contextUser, this.config);

package/src/core/QueryRefiner.ts

@@ -8,7 +8,7 @@
 import { AIEngine } from '@memberjunction/aiengine';
 import { MJAIPromptEntityExtended } from '@memberjunction/ai-core-plus';
 import { UserInfo, LogStatus } from '@memberjunction/core';
-import { extractErrorMessage } from '../utils/error-handlers';
+import { ExtractErrorMessage } from '../utils/error-handlers';
 import {
   GeneratedQuery,
   BusinessQuestion,
@@ -20,7 +20,7 @@ import {
 import { QueryTester } from './QueryTester';
 import { PROMPT_QUERY_EVALUATOR, PROMPT_QUERY_REFINER } from '../prompts/PromptNames';
 import { QueryGenConfig } from '../cli/config';
-import { executePromptWithOverrides } from '../utils/prompt-helpers';
+import { ExecutePromptWithOverrides } from '../utils/prompt-helpers';
 
 /**
  * QueryRefiner class
@@ -47,7 +47,7 @@ export class QueryRefiner {
    * @param maxRefinements - Maximum refinement iterations (default: 3)
    * @returns Refined query with test results and evaluation
    */
-  async refineQuery(
+  async RefineQuery(
     query: GeneratedQuery,
     businessQuestion: BusinessQuestion,
     entityMetadata: EntityMetadataForPrompt[],
@@ -78,7 +78,7 @@ export class QueryRefiner {
       } catch (error: unknown) {
         // Query broke during refinement - revert to last working version
         if (this.config.verbose) {
-          LogStatus(`Refinement produced broken query: ${extractErrorMessage(error, 'Refinement Test')}. Reverting to last working version.`);
+          LogStatus(`Refinement produced broken query: ${ExtractErrorMessage(error, 'Refinement Test')}. Reverting to last working version.`);
         }
 
         // If we have a previous working version, use that
@@ -147,6 +147,16 @@ export class QueryRefiner {
     );
   }
 
+  /** @deprecated Use {@link RefineQuery}. */
+  async refineQuery(
+    query: GeneratedQuery,
+    businessQuestion: BusinessQuestion,
+    entityMetadata: EntityMetadataForPrompt[],
+    maxRefinements: number = 3
+  ): Promise<RefinedQuery> {
+    return this.RefineQuery(query, businessQuestion, entityMetadata, maxRefinements);
+  }
+
   /**
    * Configure AIEngine for prompt execution
    * Ensures engine is ready before running prompts
@@ -156,7 +166,7 @@ export class QueryRefiner {
       const aiEngine = AIEngine.Instance;
       await aiEngine.Config(false, this.contextUser);
     } catch (error: unknown) {
-      throw new Error(extractErrorMessage(error, 'AIEngine Configuration'));
+      throw new Error(ExtractErrorMessage(error, 'AIEngine Configuration'));
     }
   }
 
@@ -265,7 +275,7 @@ export class QueryRefiner {
       this.logEvaluation(evaluation);
       return evaluation;
     } catch (error: unknown) {
-      throw new Error(extractErrorMessage(error, 'QueryRefiner.evaluateQuery'));
+      throw new Error(ExtractErrorMessage(error, 'QueryRefiner.evaluateQuery'));
     }
   }
 
@@ -312,7 +322,7 @@ export class QueryRefiner {
       };
     } catch (error: unknown) {
       throw new Error(
-        extractErrorMessage(error, 'QueryRefiner.performRefinement')
+        ExtractErrorMessage(error, 'QueryRefiner.performRefinement')
       );
     }
   }
@@ -340,7 +350,7 @@ export class QueryRefiner {
     prompt: MJAIPromptEntityExtended,
     promptData: Record<string, unknown>
   ): Promise<T> {
-    const result = await executePromptWithOverrides<T>(
+    const result = await ExecutePromptWithOverrides<T>(
       prompt,
       promptData,
       this.contextUser,

package/src/core/QueryTester.ts

@@ -12,7 +12,7 @@ import {
   UserInfo,
   LogError,
 } from '@memberjunction/core';
-import { extractErrorMessage } from '../utils/error-handlers';
+import { ExtractErrorMessage } from '../utils/error-handlers';
 import {
   GeneratedQuery,
   QueryTestResult,
@@ -63,7 +63,7 @@ export class QueryTester {
    * @param maxAttempts - Maximum number of retry attempts (default: 5)
    * @returns Test result with success status, SQL, and sample data
    */
-  async testQuery(
+  async TestQuery(
     query: GeneratedQuery,
     maxAttempts: number = 5
   ): Promise<QueryTestResult> {
@@ -94,7 +94,7 @@ export class QueryTester {
           attempts: attempt,
         };
       } catch (error: unknown) {
-        lastError = extractErrorMessage(error, 'Query Testing');
+        lastError = ExtractErrorMessage(error, 'Query Testing');
         if (this.config.verbose) {
           LogError(`Attempt ${attempt}/${maxAttempts} failed: ${lastError}`);
         }
@@ -114,6 +114,14 @@ export class QueryTester {
     };
   }
 
+  /** @deprecated Use {@link TestQuery}. */
+  async testQuery(
+    query: GeneratedQuery,
+    maxAttempts: number = 5
+  ): Promise<QueryTestResult> {
+    return this.TestQuery(query, maxAttempts);
+  }
+
   /**
    * Render query template with sample parameter values
    * Uses QueryParameterProcessor for proper type handling
@@ -138,7 +146,7 @@ export class QueryTester {
       return renderedSQL;
     } catch (error: unknown) {
       throw new Error(
-        `Template rendering failed: ${extractErrorMessage(error, 'Nunjucks')}`
+        `Template rendering failed: ${ExtractErrorMessage(error, 'Nunjucks')}`
       );
     }
   }
@@ -236,7 +244,7 @@ export class QueryTester {
       return result;
     } catch (error: unknown) {
       throw new Error(
-        `SQL execution failed: ${extractErrorMessage(error, 'Database')}`
+        `SQL execution failed: ${ExtractErrorMessage(error, 'Database')}`
       );
     }
   }

package/src/core/QueryWriter.ts

@@ -9,8 +9,8 @@ import { AIEngine } from '@memberjunction/aiengine';
 import { MJAIPromptEntityExtended } from '@memberjunction/ai-core-plus';
 import { UserInfo, LogStatus } from '@memberjunction/core';
 import { QueryGenConfig } from '../cli/config';
-import { extractErrorMessage } from '../utils/error-handlers';
-import { executePromptWithOverrides } from '../utils/prompt-helpers';
+import { ExtractErrorMessage } from '../utils/error-handlers';
+import { ExecutePromptWithOverrides } from '../utils/prompt-helpers';
 import { BusinessQuestion, GeneratedQuery, EntityMetadataForPrompt, GoldenQuery } from '../data/schema';
 import { PROMPT_SQL_QUERY_WRITER } from '../prompts/PromptNames';
 
@@ -33,7 +33,7 @@ export class QueryWriter {
    * @param fewShotExamples - Similar golden queries for few-shot learning
    * @returns Generated SQL query with parameters and output schema
    */
-  async generateQuery(
+  async GenerateQuery(
     businessQuestion: BusinessQuestion,
     entityMetadata: EntityMetadataForPrompt[],
     fewShotExamples: GoldenQuery[]
@@ -64,11 +64,20 @@ export class QueryWriter {
       return generatedQuery;
     } catch (error: unknown) {
       throw new Error(
-        extractErrorMessage(error, 'QueryWriter.generateQuery')
+        ExtractErrorMessage(error, 'QueryWriter.generateQuery')
       );
     }
   }
 
+  /** @deprecated Use {@link GenerateQuery}. */
+  async generateQuery(
+    businessQuestion: BusinessQuestion,
+    entityMetadata: EntityMetadataForPrompt[],
+    fewShotExamples: GoldenQuery[]
+  ): Promise<GeneratedQuery> {
+    return this.GenerateQuery(businessQuestion, entityMetadata, fewShotExamples);
+  }
+
   /**
    * Find prompt by name in AIEngine cache
    * Throws if prompt not found
@@ -105,7 +114,7 @@ export class QueryWriter {
     for (let attempt = 0; attempt <= maxRetries; attempt++) {
       try {
         // Execute AI prompt
-        const result = await executePromptWithOverrides<GeneratedQuery>(
+        const result = await ExecutePromptWithOverrides<GeneratedQuery>(
           prompt,
           promptData,
           this.contextUser,