tuneprompt 1.0.0

package/dist/storage/database.js

@@ -0,0 +1,179 @@
+"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.TestDatabase = void 0;
+const better_sqlite3_1 = __importDefault(require("better-sqlite3"));
+const path = __importStar(require("path"));
+const os = __importStar(require("os"));
+const fs = __importStar(require("fs"));
+const migrate_1 = require("../db/migrate");
+class TestDatabase {
+    db;
+    constructor(dbPath) {
+        const defaultPath = path.join(os.homedir(), '.tuneprompt', 'history.db');
+        const dir = path.dirname(dbPath || defaultPath);
+        if (!fs.existsSync(dir)) {
+            fs.mkdirSync(dir, { recursive: true });
+        }
+        this.db = new better_sqlite3_1.default(dbPath || defaultPath);
+        this.migrate();
+    }
+    migrate() {
+        this.db.exec(`
+      CREATE TABLE IF NOT EXISTS test_runs (
+        id TEXT PRIMARY KEY,
+        timestamp INTEGER NOT NULL,
+        total_tests INTEGER NOT NULL,
+        passed INTEGER NOT NULL,
+        failed INTEGER NOT NULL,
+        duration INTEGER NOT NULL
+      );
+
+      CREATE TABLE IF NOT EXISTS test_results (
+        id TEXT PRIMARY KEY,
+        run_id TEXT NOT NULL,
+        description TEXT NOT NULL,
+        prompt TEXT NOT NULL,
+        variables TEXT,
+        expect TEXT,
+        config TEXT,
+        file_path TEXT,
+        status TEXT NOT NULL,
+        score REAL NOT NULL,
+        actual_output TEXT,
+        expected_output TEXT,
+        error TEXT,
+        duration INTEGER NOT NULL,
+        tokens INTEGER,
+        cost REAL,
+        FOREIGN KEY (run_id) REFERENCES test_runs(id)
+      );
+
+      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);
+    `);
+        // 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 (?, ?, ?, ?, ?, ?)
+    `);
+        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 (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+    `);
+        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);
+        }
+    }
+    getRecentRuns(limit = 10) {
+        const runs = this.db.prepare(`
+      SELECT * FROM test_runs 
+      ORDER BY timestamp DESC 
+      LIMIT ?
+    `).all(limit);
+        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)
+        }));
+    }
+    getRunResults(runId) {
+        const results = this.db.prepare(`
+      SELECT * FROM test_results WHERE run_id = ?
+    `).all(runId);
+        return results.map(r => {
+            let prompt = r.prompt;
+            try {
+                if (prompt.startsWith('{'))
+                    prompt = JSON.parse(prompt);
+            }
+            catch (e) { }
+            let variables = null;
+            try {
+                if (r.variables)
+                    variables = JSON.parse(r.variables);
+            }
+            catch (e) { }
+            let config = null;
+            try {
+                if (r.config)
+                    config = JSON.parse(r.config);
+            }
+            catch (e) { }
+            return {
+                id: r.id,
+                testCase: {
+                    description: r.description,
+                    prompt: prompt,
+                    variables: variables,
+                    expect: r.expect || r.expected_output,
+                    config: config,
+                    filePath: r.file_path
+                },
+                status: r.status,
+                score: r.score,
+                actualOutput: r.actual_output,
+                expectedOutput: r.expected_output,
+                error: r.error,
+                metadata: {
+                    duration: r.duration,
+                    timestamp: new Date(),
+                    tokens: r.tokens,
+                    cost: r.cost
+                }
+            };
+        });
+    }
+    close() {
+        this.db.close();
+    }
+}
+exports.TestDatabase = TestDatabase;

package/dist/types/fix.d.ts

@@ -0,0 +1,28 @@
+export interface FailedTest {
+    id: string;
+    description: string;
+    prompt: string;
+    input?: Record<string, any>;
+    expectedOutput: string;
+    actualOutput: string;
+    score: number;
+    threshold: number;
+    errorType: 'semantic' | 'json' | 'exact' | 'length';
+    errorMessage: string;
+}
+export interface OptimizationResult {
+    originalPrompt: string;
+    optimizedPrompt: string;
+    reasoning: string;
+    confidence: number;
+    testResults: {
+        score: number;
+        passed: boolean;
+        output: string;
+    };
+}
+export interface FixCandidate {
+    prompt: string;
+    score: number;
+    reasoning: string;
+}

package/dist/types/fix.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/types/index.d.ts

@@ -0,0 +1,58 @@
+export interface TestCase {
+    description: string;
+    prompt: string | {
+        system?: string;
+        user: string;
+    };
+    variables?: Record<string, any>;
+    expect: string | Record<string, any>;
+    config?: {
+        threshold?: number;
+        method?: 'exact' | 'semantic' | 'json' | 'llm-judge';
+        model?: string;
+        provider?: 'openai' | 'anthropic' | 'openrouter';
+    };
+    filePath?: string;
+}
+export interface TestResult {
+    id: string;
+    testCase: TestCase;
+    status: 'pass' | 'fail' | 'error';
+    score: number;
+    actualOutput: string;
+    expectedOutput: string;
+    error?: string;
+    metadata: {
+        duration: number;
+        timestamp: Date;
+        tokens?: number;
+        cost?: number;
+        provider?: string;
+    };
+}
+export interface TestRun {
+    id: string;
+    timestamp: Date;
+    totalTests: number;
+    passed: number;
+    failed: number;
+    duration: number;
+    results: TestResult[];
+}
+export interface ProviderConfig {
+    apiKey: string;
+    model: string;
+    baseURL?: string;
+    maxTokens?: number;
+    temperature?: number;
+}
+export interface TunePromptConfig {
+    providers: {
+        openai?: ProviderConfig;
+        anthropic?: ProviderConfig;
+        openrouter?: ProviderConfig;
+    };
+    threshold?: number;
+    testDir?: string;
+    outputFormat?: 'json' | 'table' | 'both';
+}

package/dist/types/index.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/utils/analytics.d.ts

@@ -0,0 +1,2 @@
+export declare function trackEvent(userId: string, event: string, properties?: Record<string, any>): void;
+export declare function trackFixAttempt(userId: string, testCount: number, success: boolean): Promise<void>;

package/dist/utils/analytics.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.trackEvent = trackEvent;
+exports.trackFixAttempt = trackFixAttempt;
+const { PostHog } = require('posthog-node');
+const client = new PostHog(process.env.POSTHOG_KEY || 'phc_xxxxx', { host: 'https://app.posthog.com' });
+function trackEvent(userId, event, properties) {
+    if (process.env.NODE_ENV === 'production') {
+        client.capture({
+            distinctId: userId,
+            event,
+            properties
+        });
+    }
+}
+// Track in fix command
+async function trackFixAttempt(userId, testCount, success) {
+    trackEvent(userId, 'fix_attempted', {
+        test_count: testCount,
+        success
+    });
+}

package/dist/utils/config.d.ts

@@ -0,0 +1,3 @@
+import { TunePromptConfig } from '../types';
+export declare function loadConfig(configPath?: string): Promise<TunePromptConfig>;
+export declare function getDefaultConfigTemplate(): string;

package/dist/utils/config.js

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadConfig = loadConfig;
+exports.getDefaultConfigTemplate = getDefaultConfigTemplate;
+const cosmiconfig_1 = require("cosmiconfig");
+const explorer = (0, cosmiconfig_1.cosmiconfig)('tuneprompt');
+async function loadConfig(configPath) {
+    let result;
+    if (configPath) {
+        result = await explorer.load(configPath);
+    }
+    else {
+        result = await explorer.search();
+    }
+    if (!result || !result.config) {
+        throw new Error('No tuneprompt config found. Run "tuneprompt init" to create one.');
+    }
+    return validateConfig(result.config);
+}
+function validateConfig(config) {
+    if (!config.providers || Object.keys(config.providers).length === 0) {
+        throw new Error('At least one provider must be configured');
+    }
+    // Validate API keys
+    for (const [provider, cfg] of Object.entries(config.providers)) {
+        if (!cfg.apiKey) {
+            throw new Error(`API key missing for provider: ${provider}`);
+        }
+    }
+    return {
+        threshold: config.threshold || 0.8,
+        testDir: config.testDir || './tests',
+        outputFormat: config.outputFormat || 'both',
+        ...config
+    };
+}
+function getDefaultConfigTemplate() {
+    return `module.exports = {
+  providers: {
+    openai: {
+      apiKey: process.env.OPENAI_API_KEY,
+      model: 'gpt-4o',
+      maxTokens: 1000,
+      temperature: 0.7
+    },
+    anthropic: {
+      apiKey: process.env.ANTHROPIC_API_KEY,
+      model: 'claude-sonnet-4-20250514',
+      maxTokens: 1000,
+      temperature: 0.7
+    },
+    openrouter: {
+      apiKey: process.env.OPENROUTER_API_KEY,
+      model: 'nvidia/nemotron-3-nano-30b-a3b:free',
+      maxTokens: 400,
+      temperature: 0.7
+    }
+  },
+  
+  // Global semantic similarity threshold
+  threshold: 0.8,
+  
+  // Directory containing test files
+  testDir: './tests',
+  
+  // Output format: 'json', 'table', or 'both'
+  outputFormat: 'both'
+};
+`;
+}

package/dist/utils/errorHandler.d.ts

@@ -0,0 +1,14 @@
+export declare class TunePromptError extends Error {
+    code: string;
+    details?: any | undefined;
+    constructor(message: string, code: string, details?: any | undefined);
+}
+export declare function handleError(error: any): void;
+export declare const Errors: {
+    NO_LICENSE: TunePromptError;
+    INVALID_LICENSE: TunePromptError;
+    API_KEY_MISSING: TunePromptError;
+    NO_FAILED_TESTS: TunePromptError;
+    NETWORK_ERROR: TunePromptError;
+    OPTIMIZATION_FAILED: TunePromptError;
+};

package/dist/utils/errorHandler.js

@@ -0,0 +1,40 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Errors = exports.TunePromptError = void 0;
+exports.handleError = handleError;
+const chalk_1 = __importDefault(require("chalk"));
+class TunePromptError extends Error {
+    code;
+    details;
+    constructor(message, code, details) {
+        super(message);
+        this.code = code;
+        this.details = details;
+        this.name = 'TunePromptError';
+    }
+}
+exports.TunePromptError = TunePromptError;
+function handleError(error) {
+    if (error instanceof TunePromptError) {
+        console.error(chalk_1.default.red(`\n❌ Error [${error.code}]: ${error.message}\n`));
+        if (error.details) {
+            console.error(chalk_1.default.gray(JSON.stringify(error.details, null, 2)));
+        }
+    }
+    else {
+        console.error(chalk_1.default.red('\n❌ Unexpected error:'), error.message);
+    }
+    process.exit(1);
+}
+// Common errors
+exports.Errors = {
+    NO_LICENSE: new TunePromptError('No active license found', 'NO_LICENSE', { suggestion: 'Run: tuneprompt activate <subscription-id>' }),
+    INVALID_LICENSE: new TunePromptError('License validation failed', 'INVALID_LICENSE', { suggestion: 'Your subscription may have expired or been cancelled' }),
+    API_KEY_MISSING: new TunePromptError('API key not configured', 'API_KEY_MISSING', { suggestion: 'Set ANTHROPIC_API_KEY or OPENAI_API_KEY in your environment' }),
+    NO_FAILED_TESTS: new TunePromptError('No failed tests found to fix', 'NO_FAILED_TESTS', { suggestion: 'Run: tuneprompt run first' }),
+    NETWORK_ERROR: new TunePromptError('Network request failed', 'NETWORK_ERROR', { suggestion: 'Check your internet connection and try again' }),
+    OPTIMIZATION_FAILED: new TunePromptError('Failed to generate prompt optimization', 'OPTIMIZATION_FAILED', { suggestion: 'The AI service may be temporarily unavailable' })
+};

package/dist/utils/license.d.ts

@@ -0,0 +1,40 @@
+interface LicenseData {
+    subscriptionId: string;
+    email: string;
+    plan: 'pro-monthly' | 'pro-yearly' | 'lifetime';
+    activatedAt: string;
+    lastVerified: string;
+    instanceId: string;
+}
+/**
+ * Save license data locally
+ */
+export declare function saveLicense(data: LicenseData): void;
+/**
+ * Load license data from disk
+ */
+export declare function loadLicense(): LicenseData | null;
+/**
+ * Delete license from disk
+ */
+export declare function deleteLicense(): void;
+/**
+ * Main license check function
+ * Always verifies with backend to ensure real-time status
+ */
+export declare function checkLicense(): Promise<boolean>;
+/**
+ * Activate a new license
+ */
+export declare function activateLicense(subscriptionId: string, email: string, plan: 'pro-monthly' | 'pro-yearly' | 'lifetime'): Promise<boolean>;
+/**
+ * Get current license info
+ */
+export declare function getLicenseInfo(): LicenseData | null;
+/**
+ * License Manager for checking features
+ */
+export declare class LicenseManager {
+    hasFeature(feature: string): Promise<boolean>;
+}
+export {};

package/dist/utils/license.js

@@ -0,0 +1,207 @@
+"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.LicenseManager = void 0;
+exports.saveLicense = saveLicense;
+exports.loadLicense = loadLicense;
+exports.deleteLicense = deleteLicense;
+exports.checkLicense = checkLicense;
+exports.activateLicense = activateLicense;
+exports.getLicenseInfo = getLicenseInfo;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const os = __importStar(require("os"));
+const crypto = __importStar(require("crypto"));
+const axios_1 = __importDefault(require("axios"));
+const LICENSE_DIR = path.join(os.homedir(), '.tuneprompt');
+const LICENSE_FILE = path.join(LICENSE_DIR, 'license.json');
+const VERIFICATION_INTERVAL = 24 * 60 * 60 * 1000; // 24 hours
+/**
+ * Ensure license directory exists
+ */
+function ensureLicenseDir() {
+    if (!fs.existsSync(LICENSE_DIR)) {
+        fs.mkdirSync(LICENSE_DIR, { recursive: true });
+    }
+}
+/**
+ * Generate a unique machine ID
+ */
+function generateInstanceId() {
+    const hostname = os.hostname();
+    const username = os.userInfo().username;
+    const hash = crypto
+        .createHash('sha256')
+        .update(`${hostname}-${username}`)
+        .digest('hex')
+        .substring(0, 16);
+    return hash;
+}
+/**
+ * Save license data locally
+ */
+function saveLicense(data) {
+    ensureLicenseDir();
+    const encrypted = Buffer.from(JSON.stringify(data)).toString('base64');
+    fs.writeFileSync(LICENSE_FILE, encrypted, 'utf-8');
+}
+/**
+ * Load license data from disk
+ */
+function loadLicense() {
+    if (!fs.existsSync(LICENSE_FILE)) {
+        return null;
+    }
+    try {
+        const encrypted = fs.readFileSync(LICENSE_FILE, 'utf-8');
+        const decrypted = Buffer.from(encrypted, 'base64').toString('utf-8');
+        return JSON.parse(decrypted);
+    }
+    catch (error) {
+        console.error('Failed to load license:', error);
+        return null;
+    }
+}
+/**
+ * Delete license from disk
+ */
+function deleteLicense() {
+    if (fs.existsSync(LICENSE_FILE)) {
+        fs.unlinkSync(LICENSE_FILE);
+    }
+}
+/**
+ * Check if license needs verification (24h since last check)
+ */
+function needsVerification(license) {
+    const lastVerified = new Date(license.lastVerified).getTime();
+    const now = Date.now();
+    return (now - lastVerified) > VERIFICATION_INTERVAL;
+}
+/**
+ * Verify license with backend API
+ */
+async function verifyWithBackend(subscriptionId) {
+    try {
+        // Call your backend API (we'll create this in Week 3)
+        const response = await axios_1.default.post(`${process.env.TUNEPROMPT_API_URL || 'https://api.tuneprompt.com'}/api/verify-license`, {
+            subscriptionId
+        }, {
+            timeout: 5000
+        });
+        return response.data.valid === true;
+    }
+    catch (error) {
+        // Fail open: if API is down, allow access for paid users
+        console.warn('License verification failed (network issue), allowing access');
+        return true;
+    }
+}
+/**
+ * Main license check function
+ * Always verifies with backend to ensure real-time status
+ */
+async function checkLicense() {
+    const license = loadLicense();
+    if (!license) {
+        return false; // No license found
+    }
+    // Lifetime licenses don't need verification
+    if (license.plan === 'lifetime') {
+        return true;
+    }
+    // Always verify with backend to get real-time status
+    const isValid = await verifyWithBackend(license.subscriptionId);
+    if (isValid) {
+        // Update last verified timestamp
+        license.lastVerified = new Date().toISOString();
+        saveLicense(license);
+        return true;
+    }
+    else {
+        // License is invalid (expired/cancelled)
+        deleteLicense();
+        return false;
+    }
+}
+/**
+ * Activate a new license
+ */
+async function activateLicense(subscriptionId, email, plan) {
+    try {
+        // Verify the subscription is valid
+        const isValid = await verifyWithBackend(subscriptionId);
+        if (!isValid) {
+            return false;
+        }
+        const licenseData = {
+            subscriptionId,
+            email,
+            plan,
+            activatedAt: new Date().toISOString(),
+            lastVerified: new Date().toISOString(),
+            instanceId: generateInstanceId()
+        };
+        saveLicense(licenseData);
+        return true;
+    }
+    catch (error) {
+        console.error('License activation failed:', error);
+        return false;
+    }
+}
+/**
+ * Get current license info
+ */
+function getLicenseInfo() {
+    return loadLicense();
+}
+/**
+ * License Manager for checking features
+ */
+class LicenseManager {
+    async hasFeature(feature) {
+        const isValid = await checkLicense();
+        if (!isValid)
+            return false;
+        // Currently all features are available with any valid license
+        // In the future, we can add plan-specific logic here
+        return true;
+    }
+}
+exports.LicenseManager = LicenseManager;

package/dist/utils/storage.d.ts

@@ -0,0 +1,2 @@
+import { FailedTest } from '../types/fix';
+export declare function getFailedTests(): Promise<FailedTest[]>;