tuneprompt 1.0.0

package/dist/commands/init.js

@@ -0,0 +1,96 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.initCommand = initCommand;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const inquirer_1 = __importDefault(require("inquirer"));
+const chalk_1 = __importDefault(require("chalk"));
+const config_1 = require("../utils/config");
+async function initCommand() {
+    console.log(chalk_1.default.bold('\n🎛️  TunePrompt Initialization\n'));
+    const answers = await inquirer_1.default.prompt([
+        {
+            type: 'confirm',
+            name: 'createConfig',
+            message: 'Create tuneprompt.config.js?',
+            default: true
+        },
+        {
+            type: 'confirm',
+            name: 'createTests',
+            message: 'Create sample test file?',
+            default: true
+        },
+        {
+            type: 'confirm',
+            name: 'createEnv',
+            message: 'Create .env file for API keys?',
+            default: true
+        }
+    ]);
+    if (answers.createConfig) {
+        const configPath = path.join(process.cwd(), 'tuneprompt.config.js');
+        fs.writeFileSync(configPath, (0, config_1.getDefaultConfigTemplate)());
+        console.log(chalk_1.default.green('✓ Created tuneprompt.config.js'));
+    }
+    if (answers.createTests) {
+        const testsDir = path.join(process.cwd(), 'tests');
+        if (!fs.existsSync(testsDir)) {
+            fs.mkdirSync(testsDir);
+        }
+        const sampleTest = {
+            description: 'User onboarding welcome message',
+            prompt: 'Generate a friendly welcome message for a user named Alice.',
+            expect: 'Welcome, Alice! We are glad you are here.',
+            config: {
+                threshold: 0.85,
+                method: 'semantic'
+            }
+        };
+        fs.writeFileSync(path.join(testsDir, 'sample.json'), JSON.stringify(sampleTest, null, 2));
+        console.log(chalk_1.default.green('✓ Created tests/sample.json'));
+    }
+    if (answers.createEnv) {
+        const envPath = path.join(process.cwd(), '.env');
+        const envContent = `OPENAI_API_KEY=your_key_here\nANTHROPIC_API_KEY=your_key_here\nOPENROUTER_API_KEY=your_key_here\n`;
+        fs.writeFileSync(envPath, envContent);
+        console.log(chalk_1.default.green('✓ Created .env'));
+    }
+    console.log(chalk_1.default.bold('\n✨ Setup complete! Run "tuneprompt run" to test your prompts.\n'));
+}

package/dist/commands/run.d.ts

@@ -0,0 +1,9 @@
+import { Command } from 'commander';
+export interface RunOptions {
+    config?: string;
+    watch?: boolean;
+    ci?: boolean;
+    cloud?: boolean;
+}
+export declare function runTests(options?: RunOptions): Promise<void>;
+export declare const runCommand: Command;

package/dist/commands/run.js

@@ -0,0 +1,216 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runCommand = void 0;
+exports.runTests = runTests;
+const commander_1 = require("commander");
+const cloud_service_1 = require("../services/cloud.service");
+const chalk_1 = __importDefault(require("chalk"));
+const child_process_1 = require("child_process");
+const ora_1 = __importDefault(require("ora"));
+const config_1 = require("../utils/config");
+const loader_1 = require("../engine/loader");
+const runner_1 = require("../engine/runner");
+const reporter_1 = require("../engine/reporter");
+const database_1 = require("../storage/database");
+const license_1 = require("../utils/license");
+// At the end of your test run reporter
+function displayRunSummary(results) {
+    const failed = results.filter(r => r.status === 'fail');
+    const passed = results.filter(r => r.status === 'pass');
+    console.log(chalk_1.default.bold.white('\n' + '='.repeat(60)));
+    console.log(chalk_1.default.bold.white('Test Summary'));
+    console.log(chalk_1.default.bold.white('='.repeat(60)));
+    console.log(chalk_1.default.green(`✓ Passed: ${passed.length}`));
+    console.log(chalk_1.default.red(`✗ Failed: ${failed.length}`));
+    console.log(chalk_1.default.gray(`Total: ${results.length}`));
+    console.log(chalk_1.default.bold.white('='.repeat(60) + '\n'));
+    // UPSELL MESSAGE (NEW)
+    if (failed.length > 0) {
+        console.log(chalk_1.default.yellow('⚠️  ' + failed.length + ' test(s) failed'));
+        console.log(chalk_1.default.gray('\nDon\'t waste time debugging manually.'));
+        console.log(chalk_1.default.cyan('Run ') + chalk_1.default.bold.white('tuneprompt fix') + chalk_1.default.cyan(' to let AI repair these prompts instantly.\n'));
+        // Check license status
+        const licenseManager = new license_1.LicenseManager();
+        licenseManager.hasFeature('fix').then((hasAccess) => {
+            if (!hasAccess) {
+                console.log(chalk_1.default.gray('Unlock fix with: ') + chalk_1.default.white('https://tuneprompt.com/pricing'));
+                console.log(chalk_1.default.gray('Already have a key? ') + chalk_1.default.white('tuneprompt activate <key>\n'));
+            }
+        });
+    }
+}
+// Extract the core run functionality to a separate function
+async function runTests(options = {}) {
+    const startTime = Date.now();
+    const spinner = (0, ora_1.default)('Loading configuration...').start();
+    try {
+        // Load config
+        const config = await (0, config_1.loadConfig)(options.config);
+        spinner.succeed('Configuration loaded');
+        // Load tests
+        spinner.start('Loading test cases...');
+        const loader = new loader_1.TestLoader();
+        const testCases = loader.loadTestDir(config.testDir || './tests');
+        if (testCases.length === 0) {
+            spinner.fail('No test cases found');
+            process.exit(1);
+        }
+        spinner.succeed(`Loaded ${testCases.length} test case(s)`);
+        // Run tests
+        spinner.start('Running tests...');
+        const runner = new runner_1.TestRunner(config);
+        const results = await runner.runTests(testCases);
+        spinner.stop();
+        // Save to database
+        const db = new database_1.TestDatabase();
+        db.saveRun(results);
+        db.close();
+        // Report results
+        const reporter = new reporter_1.TestReporter();
+        reporter.printResults(results, config.outputFormat);
+        // Calculate results for cloud upload
+        const testResults = results.results.map((result) => {
+            // Map from internal TestResult to cloud service TestResult
+            const mappedResult = {
+                test_name: result.testCase.description,
+                test_description: result.testCase.description,
+                prompt: typeof result.testCase.prompt === 'string'
+                    ? result.testCase.prompt
+                    : JSON.stringify(result.testCase.prompt),
+                input_data: result.testCase.variables,
+                expected_output: result.expectedOutput,
+                actual_output: result.actualOutput,
+                score: result.score,
+                method: result.testCase.config?.method || 'exact',
+                status: result.status,
+                model: result.metadata.provider || '',
+                tokens_used: result.metadata.tokens,
+                latency_ms: result.metadata.duration,
+                cost_usd: result.metadata.cost,
+                error_message: result.error,
+                error_type: undefined, // No error type in current TestResult interface
+            };
+            return mappedResult;
+        });
+        // Calculate total cost from all test results
+        const totalCost = results.results.reduce((sum, result) => {
+            return sum + (result.metadata.cost || 0);
+        }, 0);
+        const resultsSummary = {
+            totalTests: results.results.length,
+            passedTests: results.passed,
+            failedTests: results.failed,
+            durationMs: Date.now() - startTime,
+            totalCost: totalCost || 0.05, // fallback value
+            tests: testResults,
+        };
+        // Print results to console (existing logic)
+        console.log(chalk_1.default.green(`\n✅ ${resultsSummary.passedTests} passed`));
+        console.log(chalk_1.default.red(`❌ ${resultsSummary.failedTests} failed\n`));
+        // Show upsell hint if tests failed
+        displayRunSummary(results.results);
+        // NEW: Cloud upload logic
+        const isCI = options.ci ||
+            process.env.CI === 'true' ||
+            !!process.env.GITHUB_ACTIONS ||
+            !!process.env.GITLAB_CI;
+        const shouldUpload = options.cloud || isCI;
+        if (shouldUpload) {
+            await uploadToCloud(resultsSummary, options);
+        }
+        // Exit with error code if tests failed
+        if (resultsSummary.failedTests > 0) {
+            process.exit(1);
+        }
+    }
+    catch (error) {
+        spinner.fail('Test run failed');
+        console.error(chalk_1.default.red(error.message));
+        process.exit(1);
+    }
+}
+exports.runCommand = new commander_1.Command('run')
+    .description('Run prompt tests')
+    .option('--cloud', 'Upload results to Tuneprompt Cloud')
+    .option('--ci', 'Run in CI mode (auto-enables --cloud)')
+    .action(async (options) => {
+    await runTests(options);
+});
+async function uploadToCloud(results, options) {
+    const cloudService = new cloud_service_1.CloudService();
+    await cloudService.init();
+    const isAuth = await cloudService.isAuthenticated();
+    if (!isAuth) {
+        console.log(chalk_1.default.yellow('\n⚠️  Not authenticated with Cloud.'));
+        console.log(chalk_1.default.gray('Results saved locally. Run `tuneprompt activate` to enable cloud sync\n'));
+        return;
+    }
+    // Get or create project
+    let projectId;
+    try {
+        const projects = await cloudService.getProjects();
+        if (projects.length === 0) {
+            console.log(chalk_1.default.blue('📁 Creating default project...'));
+            const project = await cloudService.createProject('Default Project');
+            projectId = project.id;
+            console.log(chalk_1.default.green(`✅ Project created: ${projectId}`));
+        }
+        else {
+            projectId = projects[0].id; // Use first project
+            console.log(chalk_1.default.gray(`📋 Using existing project: ${projectId}`));
+        }
+    }
+    catch (error) {
+        console.log(chalk_1.default.yellow('⚠️  Failed to get project'), error);
+        return;
+    }
+    // Get Git context
+    let gitContext = {};
+    try {
+        gitContext = {
+            commit_hash: (0, child_process_1.execSync)('git rev-parse HEAD', { encoding: 'utf-8' }).trim(),
+            branch_name: (0, child_process_1.execSync)('git rev-parse --abbrev-ref HEAD', { encoding: 'utf-8' }).trim(),
+            commit_message: (0, child_process_1.execSync)('git log -1 --pretty=%B', { encoding: 'utf-8' }).trim(),
+        };
+    }
+    catch {
+        // Not a git repo
+    }
+    // Detect CI provider
+    let ciProvider;
+    if (process.env.GITHUB_ACTIONS)
+        ciProvider = 'github';
+    else if (process.env.GITLAB_CI)
+        ciProvider = 'gitlab';
+    else if (process.env.JENKINS_HOME)
+        ciProvider = 'jenkins';
+    else if (process.env.CIRCLECI)
+        ciProvider = 'circleci';
+    // Prepare run data
+    const runData = {
+        project_id: projectId,
+        environment: options.ci || process.env.CI ? 'ci' : 'local',
+        ci_provider: ciProvider,
+        total_tests: results.totalTests,
+        passed_tests: results.passedTests,
+        failed_tests: results.failedTests,
+        duration_ms: results.durationMs,
+        cost_usd: results.totalCost,
+        started_at: new Date(Date.now() - results.durationMs).toISOString(),
+        completed_at: new Date().toISOString(),
+        test_results: results.tests,
+        ...gitContext,
+    };
+    console.log(chalk_1.default.blue('\n☁️  Uploading results to Cloud...'));
+    const uploadResult = await cloudService.uploadRun(runData);
+    if (uploadResult.success) {
+        console.log(chalk_1.default.green('✅ Results uploaded successfully'));
+        console.log(chalk_1.default.gray(`View at: ${uploadResult.url}\n`));
+    }
+    else {
+        console.log(chalk_1.default.yellow('⚠️  Failed to upload results:'), uploadResult.error);
+    }
+}

package/dist/db/migrate.d.ts

@@ -0,0 +1,2 @@
+import Database from 'better-sqlite3';
+export declare function runMigrations(db: Database.Database): Promise<void>;

package/dist/db/migrate.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runMigrations = runMigrations;
+async function runMigrations(db) {
+    // Current migrations are handled in TestDatabase constructor for now
+    // This function can be used for future schema updates
+    return;
+}

package/dist/engine/constraintExtractor.d.ts

@@ -0,0 +1,8 @@
+import { FailedTest } from '../types/fix';
+export interface ExtractedConstraints {
+    errorType: 'semantic' | 'json' | 'exact' | 'length' | 'format';
+    issues: string[];
+    suggestions: string[];
+}
+export declare function extractConstraints(test: FailedTest): ExtractedConstraints;
+export declare function generateErrorContext(test: FailedTest): string;

package/dist/engine/constraintExtractor.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractConstraints = extractConstraints;
+exports.generateErrorContext = generateErrorContext;
+function extractConstraints(test) {
+    const constraints = {
+        errorType: test.errorType,
+        issues: [],
+        suggestions: []
+    };
+    // JSON validation failures
+    if (test.errorType === 'json') {
+        constraints.issues.push('Output was not valid JSON');
+        try {
+            JSON.parse(test.actualOutput);
+        }
+        catch (e) {
+            constraints.issues.push(`JSON Error: ${e.message}`);
+        }
+        constraints.suggestions.push('Add explicit JSON formatting instructions', 'Provide a JSON schema example', 'Use delimiters like <json_output></json_output>');
+    }
+    // Semantic similarity failures
+    if (test.errorType === 'semantic') {
+        const scoreDiff = test.threshold - test.score;
+        constraints.issues.push(`Semantic similarity too low (${test.score.toFixed(2)} < ${test.threshold})`);
+        if (scoreDiff > 0.3) {
+            constraints.issues.push('Output is significantly off-topic');
+            constraints.suggestions.push('Add more specific instructions', 'Include key phrases that must appear', 'Provide examples of correct outputs');
+        }
+        else {
+            constraints.issues.push('Output is close but missing key details');
+            constraints.suggestions.push('Emphasize critical information', 'Add constraint checklist', 'Request step-by-step reasoning');
+        }
+    }
+    // Length failures
+    if (test.errorType === 'length') {
+        const actualLength = test.actualOutput.length;
+        constraints.issues.push(`Output length mismatch: ${actualLength} characters`);
+        constraints.suggestions.push('Specify exact character/word limits', 'Add "Be concise" or "Be detailed" instructions', 'Provide length reference examples');
+    }
+    return constraints;
+}
+function generateErrorContext(test) {
+    const constraints = extractConstraints(test);
+    return `
+Error Type: ${constraints.errorType.toUpperCase()}
+
+Issues Detected:
+${constraints.issues.map((issue, i) => `${i + 1}. ${issue}`).join('\n')}
+
+Recommended Fixes:
+${constraints.suggestions.map((sug, i) => `${i + 1}. ${sug}`).join('\n')}
+`.trim();
+}

package/dist/engine/loader.d.ts

@@ -0,0 +1,5 @@
+import { TestCase } from '../types';
+export declare class TestLoader {
+    loadTestFile(filePath: string): TestCase[];
+    loadTestDir(dirPath: string): TestCase[];
+}

package/dist/engine/loader.js

@@ -0,0 +1,74 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TestLoader = void 0;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const yaml = __importStar(require("js-yaml"));
+class TestLoader {
+    loadTestFile(filePath) {
+        const ext = path.extname(filePath);
+        const content = fs.readFileSync(filePath, 'utf-8');
+        if (ext === '.json') {
+            const data = JSON.parse(content);
+            const tests = Array.isArray(data) ? data : [data];
+            return tests.map(t => ({ ...t, filePath: path.resolve(filePath) }));
+        }
+        else if (ext === '.yaml' || ext === '.yml') {
+            const data = yaml.load(content);
+            const tests = Array.isArray(data) ? data : [data];
+            return tests.map(t => ({ ...t, filePath: path.resolve(filePath) }));
+        }
+        else {
+            throw new Error(`Unsupported file format: ${ext}`);
+        }
+    }
+    loadTestDir(dirPath) {
+        const tests = [];
+        const files = fs.readdirSync(dirPath);
+        for (const file of files) {
+            const filePath = path.join(dirPath, file);
+            const stat = fs.statSync(filePath);
+            if (stat.isDirectory()) {
+                tests.push(...this.loadTestDir(filePath));
+            }
+            else if (file.match(/\.(json|ya?ml)$/)) {
+                tests.push(...this.loadTestFile(filePath));
+            }
+        }
+        return tests;
+    }
+}
+exports.TestLoader = TestLoader;

package/dist/engine/metaPrompt.d.ts

@@ -0,0 +1,11 @@
+export interface MetaPromptInput {
+    originalPrompt: string;
+    testInput?: Record<string, any>;
+    expectedOutput: string;
+    actualOutput: string;
+    errorType: string;
+    errorMessage: string;
+}
+export declare function generateOptimizationPrompt(input: MetaPromptInput): string;
+export declare function generateJSONFixPrompt(input: MetaPromptInput): string;
+export declare function generateSemanticFixPrompt(input: MetaPromptInput): string;

package/dist/engine/metaPrompt.js

@@ -0,0 +1,129 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateOptimizationPrompt = generateOptimizationPrompt;
+exports.generateJSONFixPrompt = generateJSONFixPrompt;
+exports.generateSemanticFixPrompt = generateSemanticFixPrompt;
+function generateOptimizationPrompt(input) {
+    const { originalPrompt, testInput, expectedOutput, actualOutput, errorType, errorMessage } = input;
+    return `You are an elite LLM Prompt Engineer with expertise in Claude, GPT-4, and advanced prompting techniques.
+
+A prompt has failed a critical test case. Your mission is to rewrite it to pass the test while maintaining the original intent.
+
+=== FAILURE ANALYSIS ===
+
+[Original Prompt]:
+"""
+${originalPrompt}
+"""
+
+${testInput ? `[Test Input Variables]:
+${JSON.stringify(testInput, null, 2)}
+` : ''}
+
+[Expected Output]:
+"""
+${expectedOutput}
+"""
+
+[Actual Output (FAILED)]:
+"""
+${actualOutput}
+"""
+
+[Error Type]: ${errorType}
+[Error Details]: ${errorMessage}
+
+=== YOUR TASK ===
+
+1. **Root Cause Analysis**: Identify WHY the prompt failed
+   - Missing instructions?
+   - Ambiguous wording?
+   - Wrong output format specified?
+   - Tone mismatch?
+   - Missing constraints?
+
+2. **Prompt Engineering Fixes**: Apply advanced techniques:
+   - ✅ Chain-of-Thought reasoning (if logic is needed)
+   - ✅ XML tags for structure (<instructions>, <output_format>)
+   - ✅ Few-shot examples (if pattern recognition helps)
+   - ✅ Explicit constraints (length, format, tone)
+   - ✅ Role assignment ("You are a [expert]...")
+   - ✅ Output format specifications (JSON schema, markdown, etc.)
+
+3. **Generate TWO Candidate Prompts**:
+   - Candidate A: Conservative fix (minimal changes)
+   - Candidate B: Aggressive rewrite (best practices applied)
+
+=== OUTPUT FORMAT ===
+
+Return ONLY valid JSON (no markdown, no explanations):
+
+{
+  "analysis": "Brief explanation of why it failed (2-3 sentences)",
+  "candidateA": {
+    "prompt": "Your rewritten prompt here",
+    "reasoning": "Why this approach works"
+  },
+  "candidateB": {
+    "prompt": "Your alternative rewritten prompt here",
+    "reasoning": "Why this approach works"
+  }
+}
+
+CRITICAL: Return ONLY the JSON object. No preamble, no markdown backticks.`;
+}
+// Specialized prompts for different error types
+function generateJSONFixPrompt(input) {
+    return `You are a JSON Schema expert. The following prompt failed to produce valid JSON.
+
+Original Prompt:
+"""
+${input.originalPrompt}
+"""
+
+Expected JSON Structure:
+"""
+${input.expectedOutput}
+"""
+
+Actual Output (Invalid JSON):
+"""
+${input.actualOutput}
+"""
+
+Rewrite the prompt to GUARANTEE valid JSON output. Use these techniques:
+1. Explicitly state: "Return ONLY valid JSON, no markdown, no explanations"
+2. Provide the exact schema structure
+3. Add output format examples
+4. Use XML tags like <json_output> to delimit the response area
+
+Return your improved prompt as plain text (not JSON).`;
+}
+function generateSemanticFixPrompt(input) {
+    return `The prompt failed semantic similarity testing (score: too low).
+
+Original Prompt:
+"""
+${input.originalPrompt}
+"""
+
+Expected Meaning/Content:
+"""
+${input.expectedOutput}
+"""
+
+What the Model Actually Said:
+"""
+${input.actualOutput}
+"""
+
+The model's response was off-topic or missed key information.
+
+Rewrite the prompt to ensure the model:
+1. Stays on topic
+2. Includes all required information from the expected output
+3. Uses clear, specific instructions
+4. Avoids ambiguity
+
+Return your improved prompt as plain text.`;
+}

package/dist/engine/optimizer.d.ts

@@ -0,0 +1,26 @@
+import { FailedTest, OptimizationResult } from '../types/fix';
+export declare class PromptOptimizer {
+    private anthropic?;
+    private openai?;
+    constructor();
+    /**
+     * Main optimization method
+     */
+    optimize(failedTest: FailedTest): Promise<OptimizationResult>;
+    /**
+     * Select appropriate meta-prompt based on error type
+     */
+    private selectMetaPrompt;
+    /**
+     * Generate multiple fix candidates using available LLMs with fallback
+     */
+    private generateCandidates;
+    /**
+     * Shadow test each candidate and return the best one
+     */
+    private selectBestCandidate;
+    /**
+     * Fallback prompt improvement - generates a clean rewritten prompt
+     */
+    private createFallbackPrompt;
+}