tuneprompt 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 CodeForgeNet
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,151 @@
+# TunePrompt
+
+Industrial-grade testing framework for LLM prompts
+
+## Overview
+
+TunePrompt is a comprehensive testing framework designed specifically for Large Language Model (LLM) prompts. It helps developers validate, test, and optimize their prompts with industrial-grade reliability and accuracy.
+
+## Features
+
+- **Multi-provider Support**: Test prompts across OpenAI, Anthropic, OpenRouter, and other LLM providers
+- **Semantic Testing**: Compare outputs using semantic similarity rather than exact matches
+- **JSON Validation**: Validate structured JSON outputs
+- **LLM-based Judging**: Use advanced LLMs to evaluate prompt quality
+- **Watch Mode**: Automatically re-run tests when files change
+- **CI/CD Integration**: Seamlessly integrate with your CI/CD pipeline
+- **Cloud Sync**: Upload results to the TunePrompt Cloud dashboard
+- **Auto-fix Engine**: Premium feature to automatically fix failing prompts using AI
+- **Detailed Reporting**: Comprehensive test reports with scores, methods, and durations
+
+## Installation
+
+```bash
+npm install -g tuneprompt
+```
+
+## Quick Start
+
+1. Initialize a new project:
+```bash
+tuneprompt init
+```
+
+2. Create test files in the `tests` directory with your prompts and expectations
+
+3. Run tests:
+```bash
+tuneprompt run
+```
+
+4. Run tests with cloud sync (requires activation):
+```bash
+tuneprompt run --cloud
+```
+
+## Commands
+
+- `tuneprompt init`: Initialize a new TunePrompt project
+- `tuneprompt run`: Run prompt tests
+- `tuneprompt run --watch`: Run tests in watch mode
+- `tuneprompt run --cloud`: Run tests and upload results to cloud
+- `tuneprompt run --ci`: Run tests in CI mode
+- `tuneprompt fix`: Auto-fix failing prompts (Premium feature)
+- `tuneprompt history`: View test run history
+- `tuneprompt activate [subscription-id]`: Activate your Premium license
+- `tuneprompt status`: Check license status
+
+## Configuration
+
+TunePrompt uses a configuration file to define providers and settings. The default location is `tuneprompt.config.js` in your project root.
+
+Example configuration:
+```javascript
+module.exports = {
+  providers: {
+    openai: {
+      apiKey: process.env.OPENAI_API_KEY,
+      model: 'gpt-4o',
+    },
+    anthropic: {
+      apiKey: process.env.ANTHROPIC_API_KEY,
+      model: 'claude-3-opus-20240229',
+    },
+    openrouter: {
+      apiKey: process.env.OPENROUTER_API_KEY,
+      model: 'openai/gpt-4o',
+    }
+  },
+  threshold: 0.85,
+  testDir: './tests',
+  outputFormat: 'table'
+};
+```
+
+## Test File Format
+
+Tests are defined in JSON files in the `tests` directory. Each test file contains an array of test cases:
+
+```json
+[
+  {
+    "description": "User onboarding welcome message",
+    "prompt": "Generate a friendly welcome message for a user named {{name}}.",
+    "variables": {
+      "name": "Alice"
+    },
+    "expect": "Welcome, Alice! We are glad you are here.",
+    "config": {
+      "threshold": 0.85,
+      "method": "semantic",
+      "model": "gpt-4o",
+      "provider": "openai"
+    }
+  }
+]
+```
+
+## Testing Methods
+
+- `exact`: Exact string match
+- `semantic`: Semantic similarity comparison
+- `json`: JSON structure validation
+- `llm-judge`: LLM-based evaluation
+
+## Cloud Integration
+
+TunePrompt offers cloud synchronization for storing test results and viewing them in a dashboard. To use cloud features:
+
+1. Purchase a subscription at [https://tuneprompt.com](https://tuneprompt.com)
+2. Activate your license:
+```bash
+tuneprompt activate [your-subscription-id]
+```
+3. Run tests with cloud sync:
+```bash
+tuneprompt run --cloud
+```
+
+## Premium Features
+
+- **Auto-fix Engine**: Automatically repair failing prompts using AI
+- **Cloud sync & team collaboration**: Store results in the cloud and collaborate with your team
+- **Advanced diagnostics**: Detailed insights and recommendations
+
+## Environment Variables
+
+Create a `.env` file in your project root with your API keys:
+
+```env
+OPENAI_API_KEY=your_openai_api_key
+ANTHROPIC_API_KEY=your_anthropic_api_key
+OPENROUTER_API_KEY=your_openrouter_api_key
+```
+
+## Contributing
+
+Contributions are welcome! Please feel free to submit a Pull Request.
+
+## License
+
+MIT

package/dist/cli.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/cli.js

@@ -0,0 +1,146 @@
+#!/usr/bin/env node
+"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 });
+const commander_1 = require("commander");
+const chalk_1 = __importDefault(require("chalk"));
+const dotenv = __importStar(require("dotenv"));
+const init_1 = require("./commands/init");
+const run_1 = require("./commands/run");
+const history_1 = require("./commands/history");
+const fix_1 = require("./commands/fix");
+const activate_1 = require("./commands/activate");
+// Load environment variables
+dotenv.config();
+const program = new commander_1.Command();
+program
+    .name('tuneprompt')
+    .description('Industrial-grade testing framework for LLM prompts')
+    .version('1.0.0');
+program
+    .command('init')
+    .description('Initialize a new tuneprompt project')
+    .action(async () => {
+    await (0, init_1.initCommand)();
+});
+program
+    .command('run')
+    .description('Run prompt tests')
+    .option('-c, --config <path>', 'Path to config file')
+    .option('-w, --watch', 'Watch mode for continuous testing')
+    .option('--ci', 'CI mode (exit with error code on failure)')
+    .option('--cloud', 'Upload results to Tuneprompt Cloud')
+    .action(async (options) => {
+    if (options.watch) {
+        await runWatchMode(options);
+    }
+    else {
+        await (0, run_1.runTests)(options);
+    }
+});
+program
+    .command('fix')
+    .description('Auto-fix failing prompts using AI')
+    .action(async () => {
+    await (0, fix_1.fixCommand)();
+});
+program
+    .command('history')
+    .description('View test run history')
+    .option('-l, --limit <number>', 'Number of runs to show', '10')
+    .option('-d, --detailed', 'Show detailed results')
+    .action(async (options) => {
+    await (0, history_1.historyCommand)({
+        limit: parseInt(options.limit),
+        detailed: options.detailed
+    });
+});
+program
+    .command('activate')
+    .argument('[subscription-id]', 'Razorpay subscription ID')
+    .description('Activate your Premium license')
+    .action(async (subscriptionId) => {
+    await (0, activate_1.activateCommand)(subscriptionId);
+});
+program
+    .command('status')
+    .description('Check license status')
+    .action(async () => {
+    const { checkLicense, getLicenseInfo } = await Promise.resolve().then(() => __importStar(require('./utils/license')));
+    // First verify with backend (this will update DB and delete local license if cancelled)
+    const isValid = await checkLicense();
+    if (!isValid) {
+        console.log(chalk_1.default.yellow('\n⚠️  No active license found\n'));
+        console.log(chalk_1.default.gray('You are using the free tier.\n'));
+        console.log(chalk_1.default.bold('Upgrade to Premium:'));
+        console.log(chalk_1.default.gray('  ' + chalk_1.default.blue.underline('https://tuneprompt.com/pricing') + '\n'));
+        return;
+    }
+    // If license is valid, show info
+    const license = getLicenseInfo();
+    if (license) {
+        console.log(chalk_1.default.green('\n✅ Premium License Active\n'));
+        console.log(chalk_1.default.gray(`Email: ${license.email}`));
+        console.log(chalk_1.default.gray(`Plan: ${license.plan}`));
+        console.log(chalk_1.default.gray(`Activated: ${new Date(license.activatedAt).toLocaleDateString()}`));
+        console.log(chalk_1.default.gray(`Last Verified: ${new Date(license.lastVerified).toLocaleDateString()}\n`));
+    }
+});
+// Watch mode implementation
+async function runWatchMode(options) {
+    const chokidar = require('chokidar');
+    console.log(chalk_1.default.cyan('👀 Watch mode enabled. Monitoring for changes...\n'));
+    const watcher = chokidar.watch('./tests', {
+        persistent: true,
+        ignoreInitial: false
+    });
+    watcher.on('change', async (path) => {
+        console.log(chalk_1.default.dim(`\n📝 Detected change in ${path}\n`));
+        await (0, run_1.runTests)(options);
+    });
+    watcher.on('add', async (path) => {
+        console.log(chalk_1.default.dim(`\n➕ New test file: ${path}\n`));
+        await (0, run_1.runTests)(options);
+    });
+}
+// Error handling
+process.on('unhandledRejection', (error) => {
+    console.error(chalk_1.default.red('\n❌ Unhandled error:'), error.message);
+    process.exit(1);
+});
+program.parse();

package/dist/commands/activate.d.ts

@@ -0,0 +1 @@
+export declare function activateCommand(subscriptionId?: string): Promise<void>;

package/dist/commands/activate.js

@@ -0,0 +1,91 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.activateCommand = activateCommand;
+const chalk_1 = __importDefault(require("chalk"));
+const inquirer_1 = __importDefault(require("inquirer"));
+const ora_1 = __importDefault(require("ora"));
+const license_1 = require("../utils/license");
+async function activateCommand(subscriptionId) {
+    console.log(chalk_1.default.bold.cyan('\n🔑 Activate TunePrompt Premium\n'));
+    // Check if already activated
+    const existingLicense = (0, license_1.getLicenseInfo)();
+    if (existingLicense) {
+        console.log(chalk_1.default.yellow('⚠️  A license is already activated on this machine.\n'));
+        console.log(chalk_1.default.gray(`Email: ${existingLicense.email}`));
+        console.log(chalk_1.default.gray(`Plan: ${existingLicense.plan}`));
+        console.log(chalk_1.default.gray(`Activated: ${new Date(existingLicense.activatedAt).toLocaleDateString()}\n`));
+        const { overwrite } = await inquirer_1.default.prompt([{
+                type: 'confirm',
+                name: 'overwrite',
+                message: 'Do you want to replace it with a new license?',
+                default: false
+            }]);
+        if (!overwrite) {
+            console.log(chalk_1.default.gray('\nActivation cancelled.'));
+            return;
+        }
+    }
+    // Get subscription ID if not provided
+    if (!subscriptionId) {
+        const answers = await inquirer_1.default.prompt([{
+                type: 'input',
+                name: 'subscriptionId',
+                message: 'Enter your Razorpay Subscription ID:',
+                validate: (input) => {
+                    if (!input || input.trim().length === 0) {
+                        return 'Subscription ID is required';
+                    }
+                    if (!input.startsWith('sub_')) {
+                        return 'Invalid format. Razorpay Subscription IDs start with "sub_"';
+                    }
+                    return true;
+                }
+            }]);
+        subscriptionId = answers.subscriptionId;
+    }
+    const { email } = await inquirer_1.default.prompt([{
+            type: 'input',
+            name: 'email',
+            message: 'Enter your email address:',
+            validate: (input) => {
+                const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+                return emailRegex.test(input) || 'Please enter a valid email address';
+            }
+        }]);
+    const { plan } = await inquirer_1.default.prompt([{
+            type: 'list',
+            name: 'plan',
+            message: 'Select your plan:',
+            choices: [
+                { name: 'Pro Monthly (₹999/month)', value: 'pro-monthly' },
+                { name: 'Pro Yearly (₹9,999/year)', value: 'pro-yearly' },
+                { name: 'Lifetime (₹24,999 one-time)', value: 'lifetime' }
+            ]
+        }]);
+    // Activate the license
+    const spinner = (0, ora_1.default)('Verifying subscription...').start();
+    const success = await (0, license_1.activateLicense)(subscriptionId, email, plan);
+    if (success) {
+        spinner.succeed('License activated successfully!');
+        console.log(chalk_1.default.green('\n✅ TunePrompt Premium is now active!\n'));
+        console.log(chalk_1.default.bold('Premium features unlocked:'));
+        console.log(chalk_1.default.gray('  • tuneprompt fix (Auto-Fix Engine)'));
+        console.log(chalk_1.default.gray('  • Cloud sync & team collaboration'));
+        console.log(chalk_1.default.gray('  • Advanced diagnostics\n'));
+        console.log(chalk_1.default.cyan('Try running:'), chalk_1.default.bold('tuneprompt fix\n'));
+    }
+    else {
+        spinner.fail('Activation failed');
+        console.log(chalk_1.default.red('\n❌ Could not activate license\n'));
+        console.log(chalk_1.default.yellow('Possible reasons:'));
+        console.log(chalk_1.default.gray('  • Invalid subscription ID'));
+        console.log(chalk_1.default.gray('  • Subscription is not active'));
+        console.log(chalk_1.default.gray('  • Network connection issue\n'));
+        console.log(chalk_1.default.bold('Need help?'));
+        console.log(chalk_1.default.gray(`  • Check your subscription: ${chalk_1.default.blue.underline('https://razorpay.com/my-subscriptions')}`));
+        console.log(chalk_1.default.gray(`  • Contact support: ${chalk_1.default.blue.underline('support@tuneprompt.com')}\n`));
+    }
+}

package/dist/commands/fix.d.ts

@@ -0,0 +1 @@
+export declare function fixCommand(): Promise<void>;

package/dist/commands/fix.js

@@ -0,0 +1,187 @@
+"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.fixCommand = fixCommand;
+const chalk_1 = __importDefault(require("chalk"));
+const ora_1 = __importDefault(require("ora"));
+const inquirer_1 = __importDefault(require("inquirer"));
+const optimizer_1 = require("../engine/optimizer");
+const license_1 = require("../utils/license");
+const analytics_1 = require("../utils/analytics");
+const storage_1 = require("../utils/storage");
+const fs = __importStar(require("fs"));
+const errorHandler_1 = require("../utils/errorHandler");
+async function fixCommand() {
+    try {
+        console.log(chalk_1.default.bold.cyan('\n🔧 TunePrompt Fix\n'));
+        // License check with better error
+        const spinner = (0, ora_1.default)('Checking license...').start();
+        const licenseValid = await (0, license_1.checkLicense)();
+        if (!licenseValid) {
+            spinner.fail('Premium feature locked');
+            showUpgradePrompt();
+            throw errorHandler_1.Errors.NO_LICENSE;
+        }
+        spinner.succeed('License validated');
+        // Load failed tests with error handling
+        const failedTests = await (0, storage_1.getFailedTests)();
+        if (failedTests.length === 0) {
+            throw errorHandler_1.Errors.NO_FAILED_TESTS;
+        }
+        console.log(chalk_1.default.yellow(`\nFound ${failedTests.length} failed test(s):\n`));
+        failedTests.forEach((test, index) => {
+            console.log(`${index + 1}. ${chalk_1.default.bold(test.description)}`);
+            console.log(`   Score: ${chalk_1.default.red(test.score.toFixed(2))} (threshold: ${test.threshold})`);
+        });
+        // Step 3: Ask which tests to fix
+        const { selectedIndexes } = await inquirer_1.default.prompt([{
+                type: 'checkbox',
+                name: 'selectedIndexes',
+                message: 'Which tests would you like to fix?',
+                choices: failedTests.map((test, index) => ({
+                    name: `${test.description} (score: ${test.score.toFixed(2)})`,
+                    value: index,
+                    checked: true
+                }))
+            }]);
+        if (selectedIndexes.length === 0) {
+            console.log(chalk_1.default.gray('\nNo tests selected. Exiting.'));
+            return;
+        }
+        // Step 4: Optimize each selected test
+        const optimizer = new optimizer_1.PromptOptimizer();
+        for (const index of selectedIndexes) {
+            const test = failedTests[index];
+            console.log(chalk_1.default.bold(`\n\n━━━ Fixing: ${test.description} ━━━\n`));
+            try {
+                const result = await optimizer.optimize(test);
+                await showDiff(result.originalPrompt, result.optimizedPrompt, result.reasoning);
+                // Ask if user wants to apply
+                const { action } = await inquirer_1.default.prompt([{
+                        type: 'rawlist',
+                        name: 'action',
+                        message: 'What would you like to do?',
+                        choices: [
+                            { name: 'Apply this fix (Updates your test file)', value: 'apply' },
+                            { name: 'Edit before applying', value: 'edit' },
+                            { name: 'Skip this fix', value: 'skip' }
+                        ],
+                        default: 0
+                    }]);
+                if (action === 'apply') {
+                    await applyFix(test, result.optimizedPrompt);
+                    console.log(`\n${chalk_1.default.bgGreen.black(' DONE ')} ${chalk_1.default.green('Prompt updated in:')} ${chalk_1.default.bold(test.id)}`);
+                    console.log(chalk_1.default.gray('The next run will use this new prompt.\n'));
+                }
+                else if (action === 'edit') {
+                    console.log(chalk_1.default.gray('\nOpening editor... (Save and close to apply)\n'));
+                    const { edited } = await inquirer_1.default.prompt([{
+                            type: 'editor',
+                            name: 'edited',
+                            message: 'Edit the prompt (save and close when done):',
+                            default: result.optimizedPrompt
+                        }]);
+                    await applyFix(test, edited);
+                    console.log(chalk_1.default.green('✅ Edited fix applied!'));
+                }
+                else {
+                    console.log(chalk_1.default.gray('⏭️  Skipped'));
+                }
+            }
+            catch (error) {
+                console.error(chalk_1.default.red(`\n❌ Failed to optimize "${test.description}"`));
+                console.error(chalk_1.default.gray(`Reason: ${error.message}\n`));
+                continue; // Skip to next test
+            }
+        }
+        console.log(chalk_1.default.bold.green('\n\n✨ Fix session complete!\n'));
+        console.log(chalk_1.default.gray('Run `tuneprompt run` to verify your fixes.\n'));
+        // After fix completes
+        const license = (0, license_1.getLicenseInfo)();
+        if (license) {
+            (0, analytics_1.trackFixAttempt)(license.email, selectedIndexes.length, true);
+        }
+    }
+    catch (error) {
+        (0, errorHandler_1.handleError)(error);
+    }
+}
+function showUpgradePrompt() {
+    console.log(chalk_1.default.yellow('\n━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━'));
+    console.log(chalk_1.default.bold('🔒 Premium Feature: Auto-Fix Engine\n'));
+    console.log('The ' + chalk_1.default.cyan('fix') + ' command uses advanced AI to automatically');
+    console.log('repair your failing prompts.\n');
+    console.log(chalk_1.default.bold('What you get:'));
+    console.log('  ✅ AI-powered prompt optimization');
+    console.log('  ✅ Shadow testing before applying fixes');
+    console.log('  ✅ Interactive diff viewer');
+    console.log('  ✅ Unlimited fix attempts\n');
+    console.log(chalk_1.default.bold('Get Premium:'));
+    console.log(`  1. Buy a license: ${chalk_1.default.blue.underline('https://tuneprompt.com/pricing')}`);
+    console.log(`  2. Activate: ${chalk_1.default.gray('tuneprompt activate <your-key>')}\n`);
+    console.log(chalk_1.default.yellow('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n'));
+}
+async function showDiff(original, optimized, reasoning) {
+    const diffLib = await Promise.resolve().then(() => __importStar(require('diff')));
+    console.log(chalk_1.default.bold('\n💡 AI Analysis:'));
+    console.log(chalk_1.default.gray(reasoning));
+    console.log(chalk_1.default.bold('\n📝 Proposed Changes:\n'));
+    const diff = diffLib.diffWords(original, optimized);
+    diff.forEach((part) => {
+        const color = part.added ? chalk_1.default.green :
+            part.removed ? chalk_1.default.red :
+                chalk_1.default.gray;
+        const prefix = part.added ? '+ ' :
+            part.removed ? '- ' :
+                '  ';
+        process.stdout.write(color(prefix + part.value));
+    });
+    console.log('\n');
+}
+async function applyFix(test, newPrompt) {
+    // This assumes prompts are stored in JSON test files
+    // Adjust based on your Phase 1 implementation
+    const testFilePath = test.id; // Assuming ID stores file path
+    if (!fs.existsSync(testFilePath)) {
+        console.error(chalk_1.default.red(`Test file not found: ${testFilePath}`));
+        return;
+    }
+    const testData = JSON.parse(fs.readFileSync(testFilePath, 'utf-8'));
+    testData.prompt = newPrompt;
+    fs.writeFileSync(testFilePath, JSON.stringify(testData, null, 2));
+}

package/dist/commands/history.d.ts

@@ -0,0 +1,5 @@
+export interface HistoryOptions {
+    limit?: number;
+    detailed?: boolean;
+}
+export declare function historyCommand(options: HistoryOptions): Promise<void>;

package/dist/commands/history.js

@@ -0,0 +1,63 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.historyCommand = historyCommand;
+const chalk_1 = __importDefault(require("chalk"));
+const cli_table3_1 = __importDefault(require("cli-table3"));
+const database_1 = require("../storage/database");
+async function historyCommand(options) {
+    const db = new database_1.TestDatabase();
+    const runs = db.getRecentRuns(options.limit || 10);
+    db.close();
+    if (runs.length === 0) {
+        console.log(chalk_1.default.yellow('No test history found. Run some tests first!'));
+        return;
+    }
+    console.log(chalk_1.default.bold('\n📊 Test History\n'));
+    const table = new cli_table3_1.default({
+        head: ['Date', 'Total', 'Passed', 'Failed', 'Duration', 'Pass Rate'],
+        colWidths: [20, 8, 10, 10, 12, 12]
+    });
+    for (const run of runs) {
+        const passRate = ((run.passed / run.totalTests) * 100).toFixed(1);
+        const passRateColor = parseFloat(passRate) >= 80
+            ? chalk_1.default.green
+            : parseFloat(passRate) >= 50
+                ? chalk_1.default.yellow
+                : chalk_1.default.red;
+        table.push([
+            run.timestamp.toLocaleString(),
+            run.totalTests,
+            chalk_1.default.green(run.passed),
+            chalk_1.default.red(run.failed),
+            `${run.duration}ms`,
+            passRateColor(`${passRate}%`)
+        ]);
+    }
+    console.log(table.toString());
+    if (options.detailed) {
+        console.log(chalk_1.default.bold('\n📝 Detailed Results\n'));
+        for (const run of runs) {
+            console.log(chalk_1.default.dim(`\nRun: ${run.id}`));
+            console.log(chalk_1.default.dim(`Date: ${run.timestamp.toLocaleString()}\n`));
+            const detailTable = new cli_table3_1.default({
+                head: ['Status', 'Test', 'Score'],
+                colWidths: [10, 50, 10]
+            });
+            for (const result of run.results) {
+                const status = result.status === 'pass'
+                    ? chalk_1.default.green('✓')
+                    : chalk_1.default.red('✗');
+                detailTable.push([
+                    status,
+                    result.testCase.description,
+                    result.score.toFixed(2)
+                ]);
+            }
+            console.log(detailTable.toString());
+        }
+    }
+    console.log();
+}

package/dist/commands/init.d.ts

@@ -0,0 +1 @@
+export declare function initCommand(): Promise<void>;