tuneprompt 1.0.5 → 1.0.7

package/dist/commands/init.js

@@ -91,9 +91,6 @@ async function initCommand() {
         const envContent = `OPENAI_API_KEY=your_key_here
 ANTHROPIC_API_KEY=your_key_here
 OPENROUTER_API_KEY=your_key_here
-
-# For self-hosted or local testing:
-# TUNEPROMPT_API_URL=http://localhost:3000
 `;
         fs.writeFileSync(envPath, envContent);
         console.log(chalk_1.default.green('✓ Created .env'));

package/dist/commands/run.js

@@ -65,64 +65,25 @@ async function runTests(options = {}) {
         const results = await runner.runTests(testCases);
         spinner.stop();
         // Save to database
+        // Save to database
         const db = new database_1.TestDatabase();
         db.saveRun(results);
-        db.close();
+        // Calculate results for cloud upload (and for sync logic)
+        const currentRunId = results.id; // Assuming results has ID
         // 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);
+            await syncPendingRuns(db, options);
         }
+        db.close();
         // Exit with error code if tests failed
-        if (resultsSummary.failedTests > 0) {
+        if (results.failed > 0) {
             process.exit(1);
         }
     }
@@ -139,35 +100,34 @@ exports.runCommand = new commander_1.Command('run')
     .action(async (options) => {
     await runTests(options);
 });
-async function uploadToCloud(results, options) {
+async function syncPendingRuns(db, options) {
+    const pendingRuns = db.getPendingUploads();
+    if (pendingRuns.length === 0)
+        return;
+    console.log(chalk_1.default.blue(`\n☁️  Syncing ${pendingRuns.length} pending run(s) to Cloud...`));
     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'));
+    if (!(await cloudService.isAuthenticated())) {
+        console.log(chalk_1.default.yellow('⚠️  Not authenticated. Run `tuneprompt activate` first.'));
         return;
     }
-    // Get or create project
+    // Get project ID once
     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}`));
+            projectId = projects[0].id;
         }
     }
-    catch (error) {
-        console.log(chalk_1.default.yellow('⚠️  Failed to get project'), error);
+    catch (err) {
+        console.log(chalk_1.default.yellow('⚠️  Failed to get project info'));
         return;
     }
-    // Get Git context
+    // Common Git/Env context
     let gitContext = {};
     try {
         gitContext = {
@@ -176,10 +136,7 @@ async function uploadToCloud(results, options) {
             commit_message: (0, child_process_1.execSync)('git log -1 --pretty=%B', { encoding: 'utf-8' }).trim(),
         };
     }
-    catch {
-        // Not a git repo
-    }
-    // Detect CI provider
+    catch { }
     let ciProvider;
     if (process.env.GITHUB_ACTIONS)
         ciProvider = 'github';
@@ -189,28 +146,43 @@ async function uploadToCloud(results, options) {
         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);
+    // Upload each run
+    for (const run of pendingRuns) {
+        const runData = {
+            project_id: projectId,
+            environment: options.ci ? 'ci' : 'local',
+            ci_provider: ciProvider,
+            total_tests: run.totalTests,
+            passed_tests: run.passed,
+            failed_tests: run.failed,
+            duration_ms: run.duration,
+            cost_usd: run.results.reduce((sum, r) => sum + (r.metadata.cost || 0), 0) || 0.05, // fallback
+            started_at: new Date(run.timestamp.getTime() - run.duration).toISOString(),
+            completed_at: run.timestamp.toISOString(),
+            test_results: run.results.map(r => ({
+                test_name: r.testCase.description,
+                test_description: r.testCase.description,
+                prompt: typeof r.testCase.prompt === 'string' ? r.testCase.prompt : JSON.stringify(r.testCase.prompt),
+                input_data: r.testCase.variables,
+                expected_output: r.expectedOutput,
+                actual_output: r.actualOutput,
+                score: r.score,
+                method: r.testCase.config?.method || 'exact',
+                status: r.status,
+                model: r.metadata.provider || '',
+                tokens_used: r.metadata.tokens,
+                latency_ms: r.metadata.duration,
+                cost_usd: r.metadata.cost,
+            })),
+            ...gitContext // Applying current git context to old runs slightly inaccurate but acceptable
+        };
+        const uploadResult = await cloudService.uploadRun(runData);
+        if (uploadResult.success) {
+            db.markAsUploaded(run.id);
+            console.log(chalk_1.default.green(`  ✓ Uploaded run from ${run.timestamp.toLocaleTimeString()}`));
+        }
+        else {
+            console.log(chalk_1.default.red(`  ✗ Failed to upload run ${run.id}: ${uploadResult.error}`));
+        }
     }
 }

package/dist/engine/optimizer.d.ts

@@ -2,6 +2,7 @@ import { FailedTest, OptimizationResult } from '../types/fix';
 export declare class PromptOptimizer {
     private anthropic?;
     private openai?;
+    private openrouter?;
     constructor();
     /**
      * Main optimization method

package/dist/engine/optimizer.js

@@ -44,19 +44,34 @@ const constraintExtractor_1 = require("./constraintExtractor");
 class PromptOptimizer {
     anthropic;
     openai;
+    openrouter;
     constructor() {
         const anthropicKey = process.env.ANTHROPIC_API_KEY;
-        if (anthropicKey && !anthropicKey.startsWith('api_key') && anthropicKey !== 'phc_xxxxx') {
+        if (anthropicKey &&
+            !anthropicKey.includes('your_key') &&
+            !anthropicKey.startsWith('api_key') &&
+            anthropicKey !== 'phc_xxxxx') {
             this.anthropic = new sdk_1.default({
                 apiKey: anthropicKey
             });
         }
         const openaiKey = process.env.OPENAI_API_KEY;
-        if (openaiKey && !openaiKey.startsWith('api_key')) {
+        if (openaiKey && !openaiKey.includes('your_key')) {
             this.openai = new openai_1.default({
                 apiKey: openaiKey
             });
         }
+        const openrouterKey = process.env.OPENROUTER_API_KEY;
+        if (openrouterKey && !openrouterKey.includes('your_key')) {
+            this.openrouter = new openai_1.default({
+                baseURL: 'https://openrouter.ai/api/v1',
+                apiKey: openrouterKey,
+                defaultHeaders: {
+                    'HTTP-Referer': 'https://tuneprompt.xyz',
+                    'X-Title': 'TunePrompt CLI',
+                },
+            });
+        }
     }
     /**
      * Main optimization method
@@ -118,7 +133,7 @@ class PromptOptimizer {
                 if (provider === 'anthropic' && this.anthropic) {
                     console.log(`⚡ Using Anthropic for candidate generation...`);
                     const response = await this.anthropic.messages.create({
-                        model: 'claude-sonnet-4-20250514',
+                        model: 'claude-3-5-sonnet-20240620',
                         max_tokens: 4000,
                         temperature: 0.7, // Some creativity for prompt rewriting
                         messages: [{
@@ -174,16 +189,34 @@ class PromptOptimizer {
                         }
                     ];
                 }
-                else if (provider === 'openrouter') {
-                    // For OpenRouter, we'll use the shadowTester to get a response
+                else if (provider === 'openrouter' && this.openrouter) {
                     console.log(`⚡ Using OpenRouter for candidate generation...`);
-                    // Since OpenRouter is used in shadow testing, we'll use a different approach
-                    // For now, we'll return a basic fallback since OpenRouter doesn't support structured outputs as well
-                    return [{
-                            prompt: this.createFallbackPrompt(failedTest),
-                            reasoning: 'Generated using fallback method',
+                    const response = await this.openrouter.chat.completions.create({
+                        model: 'anthropic/claude-3-sonnet', // Default robust model on OpenRouter
+                        messages: [{
+                                role: 'user',
+                                content: metaPrompt
+                            }],
+                        response_format: { type: 'json_object' }
+                    });
+                    const content = response.choices[0]?.message?.content;
+                    if (!content) {
+                        // Fallback if model doesn't support JSON mode or returns empty
+                        throw new Error('No content returned from OpenRouter');
+                    }
+                    const parsed = JSON.parse(content);
+                    return [
+                        {
+                            prompt: parsed.candidateA.prompt,
+                            reasoning: parsed.candidateA.reasoning,
                             score: 0
-                        }];
+                        },
+                        {
+                            prompt: parsed.candidateB.prompt,
+                            reasoning: parsed.candidateB.reasoning,
+                            score: 0
+                        }
+                    ];
                 }
             }
             catch (error) {
@@ -195,7 +228,7 @@ class PromptOptimizer {
         console.error('All providers failed for candidate generation');
         return [{
                 prompt: this.createFallbackPrompt(failedTest),
-                reasoning: 'Fallback prompt with basic improvements',
+                reasoning: 'Generated using fallback method',
                 score: 0
             }];
     }

package/dist/services/cloud.service.js

@@ -10,7 +10,7 @@ class CloudService {
     backendUrl;
     subscriptionId;
     constructor() {
-        this.backendUrl = process.env.TUNEPROMPT_API_URL || process.env.BACKEND_URL || 'https://api.tuneprompt.com';
+        this.backendUrl = process.env.TUNEPROMPT_API_URL || process.env.BACKEND_URL || 'https://i8e3mu8jlk.execute-api.ap-south-1.amazonaws.com/dev';
     }
     async init() {
         // Load subscription ID from local storage (Phase 2 activation)
@@ -21,9 +21,16 @@ class CloudService {
         return license?.subscriptionId;
     }
     async uploadRun(data) {
-        if (!this.subscriptionId) {
+        // Enforce Pro plan check
+        const license = (0, license_1.loadLicense)();
+        if (!this.subscriptionId || !license) {
             return { success: false, error: 'Not activated. Run `tuneprompt activate` first.' };
         }
+        // Check for specific pro plans (if we ever add free tiers)
+        const proPlans = ['pro-monthly', 'pro-yearly', 'lifetime'];
+        if (!proPlans.includes(license.plan)) {
+            return { success: false, error: 'Cloud features are restricted to Pro users. Please upgrade your plan.' };
+        }
         try {
             const response = await axios_1.default.post(`${this.backendUrl}/api/cloud/ingest-run`, data, {
                 headers: {

package/dist/storage/database.d.ts

@@ -5,6 +5,8 @@ export declare class TestDatabase {
     private migrate;
     saveRun(run: TestRun): void;
     getRecentRuns(limit?: number): TestRun[];
+    getPendingUploads(): TestRun[];
+    markAsUploaded(runId: string): void;
     private getRunResults;
     close(): void;
 }

package/dist/storage/database.js

@@ -87,26 +87,38 @@ class TestDatabase {
       CREATE INDEX IF NOT EXISTS idx_run_timestamp ON test_runs(timestamp);
       CREATE INDEX IF NOT EXISTS idx_result_run ON test_results(run_id);
     `);
+        // Migration for uploaded status
+        try {
+            this.db.exec(`ALTER TABLE test_runs ADD COLUMN uploaded INTEGER DEFAULT 0`);
+        }
+        catch (e) {
+            // Column might already exist
+        }
+        // Migration for provider column
+        try {
+            this.db.exec(`ALTER TABLE test_results ADD COLUMN provider TEXT`);
+        }
+        catch (e) {
+            // Column might already exist
+        }
         // Run external migrations (Phase 2)
-        // Note: runMigrations is async but contains synchronous better-sqlite3 calls
-        // so it executes immediately. We catch any promise rejection just in case.
         (0, migrate_1.runMigrations)(this.db).catch((err) => {
             console.error('Phase 2 migration failed:', err);
         });
     }
     saveRun(run) {
         const insertRun = this.db.prepare(`
-      INSERT INTO test_runs (id, timestamp, total_tests, passed, failed, duration)
-      VALUES (?, ?, ?, ?, ?, ?)
+      INSERT INTO test_runs (id, timestamp, total_tests, passed, failed, duration, uploaded)
+      VALUES (?, ?, ?, ?, ?, ?, 0)
     `);
         insertRun.run(run.id, run.timestamp.getTime(), run.totalTests, run.passed, run.failed, run.duration);
         const insertResult = this.db.prepare(`
       INSERT INTO test_results 
-      (id, run_id, description, prompt, variables, expect, config, file_path, status, score, actual_output, expected_output, error, duration, tokens, cost)
-      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+      (id, run_id, description, prompt, variables, expect, config, file_path, status, score, actual_output, expected_output, error, duration, tokens, cost, provider)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
     `);
         for (const result of run.results) {
-            insertResult.run(result.id, run.id, result.testCase.description, typeof result.testCase.prompt === 'string' ? result.testCase.prompt : JSON.stringify(result.testCase.prompt), result.testCase.variables ? JSON.stringify(result.testCase.variables) : null, typeof result.testCase.expect === 'string' ? result.testCase.expect : JSON.stringify(result.testCase.expect), result.testCase.config ? JSON.stringify(result.testCase.config) : null, result.testCase.filePath || null, result.status, result.score, result.actualOutput, result.expectedOutput, result.error || null, result.metadata.duration, result.metadata.tokens || null, result.metadata.cost || null);
+            insertResult.run(result.id, run.id, result.testCase.description, typeof result.testCase.prompt === 'string' ? result.testCase.prompt : JSON.stringify(result.testCase.prompt), result.testCase.variables ? JSON.stringify(result.testCase.variables) : null, typeof result.testCase.expect === 'string' ? result.testCase.expect : JSON.stringify(result.testCase.expect), result.testCase.config ? JSON.stringify(result.testCase.config) : null, result.testCase.filePath || null, result.status, result.score, result.actualOutput, result.expectedOutput, result.error || null, result.metadata.duration, result.metadata.tokens || null, result.metadata.cost || null, result.metadata.provider || null);
         }
     }
     getRecentRuns(limit = 10) {
@@ -125,6 +137,25 @@ class TestDatabase {
             results: this.getRunResults(run.id)
         }));
     }
+    getPendingUploads() {
+        const runs = this.db.prepare(`
+      SELECT * FROM test_runs 
+      WHERE uploaded = 0 OR uploaded IS NULL
+      ORDER BY timestamp ASC
+    `).all();
+        return runs.map(run => ({
+            id: run.id,
+            timestamp: new Date(run.timestamp),
+            totalTests: run.total_tests,
+            passed: run.passed,
+            failed: run.failed,
+            duration: run.duration,
+            results: this.getRunResults(run.id)
+        }));
+    }
+    markAsUploaded(runId) {
+        this.db.prepare(`UPDATE test_runs SET uploaded = 1 WHERE id = ?`).run(runId);
+    }
     getRunResults(runId) {
         const results = this.db.prepare(`
       SELECT * FROM test_results WHERE run_id = ?
@@ -167,7 +198,8 @@ class TestDatabase {
                     duration: r.duration,
                     timestamp: new Date(),
                     tokens: r.tokens,
-                    cost: r.cost
+                    cost: r.cost,
+                    provider: r.provider
                 }
             };
         });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tuneprompt",
-  "version": "1.0.5",
+  "version": "1.0.7",
   "description": "Industrial-grade testing framework for LLM prompts",
   "repository": {
     "type": "git",