tx-ai-db-pro 1.0.0

package/README.md

@@ -0,0 +1,104 @@
+# tx-ai-db-pro
+
+Premium SQLite wrapper for AI conversations with auto-migration, search, and formatted responses.
+
+**OpenAI API Compatible Format only.**
+
+## Installation
+
+```bash
+npm install tx-ai-db-pro
+```
+
+**This package is FREE to install and use for basic operations (retrieve, update, delete).**
+
+## Unlock Pro Features ($40)
+
+**Pro Features:**
+- Auto-migration: Point to conversation folder, auto-discovers and imports ALL conversations (2,000+)
+- Search: Drop JSON with search term, get formatted results
+- Response formatting: Specify title, summary format, etc.
+- File cleanup: Auto-remove or backup after processing
+
+**How to Unlock:**
+
+1. **Install the package:**
+   ```bash
+   npm install tx-ai-db-pro
+   ```
+
+2. **Sponsor at $40 tier** on [GitHub Sponsors](https://github.com/sponsors/TX-AI-Series)
+
+3. **Wait for key activation** (up to 48 hours - we process keys as quickly as possible, but weekends/holidays may cause delays)
+
+4. **Run the unlock wizard:**
+   ```bash
+   npm run unlock
+   ```
+   Enter your GitHub username when prompted
+
+5. **Pro features unlocked!**
+
+**Return a key (uninstall):**
+```bash
+npm run return
+```
+This returns your key so you can activate it on a different machine.
+
+## Setup
+
+```bash
+npm run setup
+```
+
+The setup wizard will:
+1. Ask for your SDK/API endpoint
+2. Fetch the schema
+3. List all fields containing "id"
+4. You select which field is your conversation ID
+5. Point to your conversation folder
+6. Auto-import ALL conversations (requires pro license)
+
+## Usage
+
+### Basic Operations (FREE)
+
+```javascript
+const TXAIDbPro = require('tx-ai-db-pro');
+const db = new TXAIDbPro();
+
+// Retrieve
+const conv = db.retrieve('conv_123');
+
+// Update/Insert
+db.update({ id: 'conv_123', messages: [...] });
+
+// Delete
+db.delete('conv_123');
+
+// List
+const all = db.listConversations();
+```
+
+### Pro Features (Requires License)
+
+```javascript
+// Search with formatting
+const results = db.search({
+  query: "hello world",
+  format: { title: true, summary: 'first_last' }
+});
+
+// Auto-migrate folder
+db.migrateFolder('./my-conversations-folder');
+```
+
+## Pricing
+
+$40 one-time payment via GitHub Sponsors. 4 installations per license. No subscriptions.
+
+$5 per extra key (contact us).
+
+## Funding
+
+If you find this useful, consider sponsoring: https://github.com/sponsors/TX-AI-Series

package/package.json

@@ -0,0 +1,43 @@
+{
+  "name": "tx-ai-db-pro",
+  "version": "1.0.0",
+  "description": "Premium SQLite wrapper for AI conversations with auto-migration, search, and formatted responses. OpenAI API Compatible Format only.",
+  "main": "src/index.js",
+  "scripts": {
+    "test": "node tests/test.js",
+    "setup": "node src/setup-wizard.js",
+    "unlock": "node src/unlock.js",
+    "return": "node src/unlock.js return",
+    "postinstall": "node src/postinstall.js"
+  },
+  "keywords": [
+    "sqlite",
+    "ai",
+    "chat",
+    "conversation",
+    "openai",
+    "database",
+    "file-driven",
+    "pro",
+    "search",
+    "migration"
+  ],
+  "author": "TX-AI-Series",
+  "license": "COMMERCIAL",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/TX-AI-Series/tx-ai-db-pro"
+  },
+  "funding": {
+    "type": "github",
+    "url": "https://github.com/sponsors/TX-AI-Series"
+  },
+  "dependencies": {
+    "better-sqlite3": "^9.4.3"
+  },
+  "files": [
+    "src/",
+    "README.md",
+    "sqlite-source/"
+  ]
+}

package/src/github-key-server.js

@@ -0,0 +1,99 @@
+const https = require('https');
+const http = require('http');
+
+/**
+ * GitHub Pages Key Server
+ * Fetches license keys from GitHub Pages hosted keys.json
+ */
+
+class GitHubKeyServer {
+  constructor(config = {}) {
+    this.keysUrl = config.keysUrl || 'https://raw.githubusercontent.com/TX-AI-Series/tx-ai-db-pro-keys/main/keys.json';
+  }
+
+  /**
+   * Fetch keys from GitHub Pages
+   */
+  fetchKeys() {
+    return new Promise((resolve, reject) => {
+      const url = new URL(this.keysUrl);
+      const lib = url.protocol === 'https:' ? https : http;
+      
+      const req = lib.request(this.keysUrl, { method: 'GET' }, (res) => {
+        if (res.statusCode === 404) {
+          reject(new Error('Keys file not found on GitHub Pages'));
+          return;
+        }
+        
+        let data = '';
+        res.on('data', (chunk) => { data += chunk; });
+        res.on('end', () => {
+          try {
+            const keysData = JSON.parse(data);
+            resolve(keysData);
+          } catch (e) {
+            reject(new Error('Failed to parse keys JSON'));
+          }
+        });
+      });
+      
+      req.on('error', reject);
+      req.end();
+    });
+  }
+
+  /**
+   * Get keys for a specific GitHub username
+   */
+  async getKeysForUser(username) {
+    const keysData = await this.fetchKeys();
+    
+    if (!keysData.sponsors || !keysData.sponsors[username]) {
+      return {
+        found: false,
+        message: `No keys found for GitHub user: ${username}. If you recently sponsored, please wait up to 48 hours for key activation.`
+      };
+    }
+
+    const sponsor = keysData.sponsors[username];
+    
+    return {
+      found: true,
+      username: username,
+      keys: sponsor.keys,
+      active: sponsor.active,
+      sponsoredAt: sponsor.sponsoredAt,
+      tier: sponsor.tier
+    };
+  }
+
+  /**
+   * Get an available (inactive) key for a user
+   */
+  async getAvailableKey(username) {
+    const userData = await this.getKeysForUser(username);
+    
+    if (!userData.found) {
+      return userData;
+    }
+
+    // Find first inactive key
+    for (let i = 0; i < userData.keys.length; i++) {
+      if (!userData.active[i]) {
+        return {
+          found: true,
+          key: userData.keys[i],
+          installNumber: i + 1,
+          username: username
+        };
+      }
+    }
+
+    return {
+      found: false,
+      message: 'All 4 keys are already active for this user. Use "npm run return" to free up a key.'
+    };
+  }
+}
+
+module.exports = GitHubKeyServer;

package/src/index.js

@@ -0,0 +1,301 @@
+const Database = require('better-sqlite3');
+const path = require('path');
+const fs = require('fs');
+const LicenseValidator = require('./license');
+
+class TXAIDbPro {
+  constructor(config = {}) {
+    this.dbPath = config.dbPath || path.join(process.cwd(), 'pro.db');
+    this.conversationIdField = config.conversationIdField || 'id';
+    this.db = null;
+    this.license = new LicenseValidator();
+    this.init();
+  }
+
+  init() {
+    this.db = new Database(this.dbPath);
+    this.db.pragma('journal_mode = WAL');
+    this.db.pragma('foreign_keys = ON');
+    this.createTables();
+  }
+
+  createTables() {
+    this.db.exec(`
+      CREATE TABLE IF NOT EXISTS conversations (
+        id TEXT PRIMARY KEY,
+        raw_data JSON NOT NULL,
+        title TEXT,
+        created_at TEXT DEFAULT (datetime('now')),
+        updated_at TEXT DEFAULT (datetime('now'))
+      );
+
+      CREATE TABLE IF NOT EXISTS messages (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        conversation_id TEXT NOT NULL,
+        message_index INTEGER NOT NULL,
+        role TEXT NOT NULL,
+        content TEXT,
+        raw_data JSON NOT NULL,
+        FOREIGN KEY (conversation_id) REFERENCES conversations(id) ON DELETE CASCADE
+      );
+
+      CREATE INDEX IF NOT EXISTS idx_messages_conversation ON messages(conversation_id);
+      CREATE INDEX IF NOT EXISTS idx_messages_role ON messages(role);
+      CREATE INDEX IF NOT EXISTS idx_conversations_title ON conversations(title);
+    `);
+  }
+
+  /**
+   * Check if pro features are unlocked
+   */
+  _requirePro(featureName) {
+    if (!this.license.isProUnlocked()) {
+      throw new Error(`Pro feature "${featureName}" is locked. Add your license keys to .license file or run "npm run unlock".`);
+    }
+  }
+
+  /**
+   * Retrieve a conversation by ID (FREE - works without license)
+   */
+  retrieve(conversationId) {
+    const conversation = this.db.prepare(
+      'SELECT * FROM conversations WHERE id = ?'
+    ).get(conversationId);
+
+    if (!conversation) return null;
+
+    const messages = this.db.prepare(
+      'SELECT * FROM messages WHERE conversation_id = ? ORDER BY message_index'
+    ).all(conversationId);
+
+    return {
+      ...conversation,
+      messages: messages.map(m => JSON.parse(m.raw_data))
+    };
+  }
+
+  /**
+   * Update or insert a conversation (FREE - works without license)
+   */
+  update(conversationData) {
+    const conversationId = conversationData[this.conversationIdField];
+    if (!conversationId) {
+      throw new Error(`Missing conversation ID field: ${this.conversationIdField}`);
+    }
+
+    const existing = this.db.prepare(
+      'SELECT id FROM conversations WHERE id = ?'
+    ).get(conversationId);
+
+    // Extract title from metadata or first message
+    let title = conversationData.metadata?.title || 
+                conversationData.title ||
+                (conversationData.messages?.[0]?.content || '').substring(0, 50) ||
+                'Untitled';
+
+    const tx = this.db.transaction(() => {
+      if (existing) {
+        this.db.prepare(
+          'UPDATE conversations SET raw_data = ?, title = ?, updated_at = datetime(\'now\') WHERE id = ?'
+        ).run(JSON.stringify(conversationData), title, conversationId);
+
+        this.db.prepare(
+          'DELETE FROM messages WHERE conversation_id = ?'
+        ).run(conversationId);
+      } else {
+        this.db.prepare(
+          'INSERT INTO conversations (id, raw_data, title) VALUES (?, ?, ?)'
+        ).run(conversationId, JSON.stringify(conversationData), title);
+      }
+
+      // Insert messages
+      const messages = conversationData.messages || [];
+      const insertMsg = this.db.prepare(
+        'INSERT INTO messages (conversation_id, message_index, role, content, raw_data) VALUES (?, ?, ?, ?, ?)'
+      );
+
+      for (let i = 0; i < messages.length; i++) {
+        const msg = messages[i];
+        insertMsg.run(
+          conversationId,
+          i,
+          msg.role || 'unknown',
+          typeof msg.content === 'string' ? msg.content : JSON.stringify(msg.content),
+          JSON.stringify(msg)
+        );
+      }
+    });
+
+    tx();
+    return true;
+  }
+
+  /**
+   * Delete a conversation by ID (FREE - works without license)
+   */
+  delete(conversationId) {
+    const result = this.db.prepare(
+      'DELETE FROM conversations WHERE id = ?'
+    ).run(conversationId);
+
+    return result.changes > 0;
+  }
+
+  /**
+   * Search conversations with customizable response formatting (PRO - requires license)
+   */
+  search(options = {}) {
+    this._requirePro('search');
+
+    const {
+      query = '',
+      format = { title: true, summary: 'first_last' },
+      limit = 20,
+      offset = 0
+    } = options;
+
+    let results;
+
+    if (query) {
+      results = this.db.prepare(`
+        SELECT DISTINCT c.id, c.title, c.created_at, c.updated_at, c.raw_data
+        FROM conversations c
+        JOIN messages m ON c.id = m.conversation_id
+        WHERE m.content LIKE ? OR c.title LIKE ?
+        ORDER BY c.updated_at DESC
+        LIMIT ? OFFSET ?
+      `).all(`%${query}%`, `%${query}%`, limit, offset);
+    } else {
+      results = this.db.prepare(`
+        SELECT id, title, created_at, updated_at, raw_data
+        FROM conversations
+        ORDER BY updated_at DESC
+        LIMIT ? OFFSET ?
+      `).all(limit, offset);
+    }
+
+    // Format results
+    return results.map(conv => {
+      const formatted = {
+        id: conv.id,
+        created_at: conv.created_at,
+        updated_at: conv.updated_at
+      };
+
+      if (format.title) {
+        formatted.title = conv.title;
+      }
+
+      if (format.summary === 'first_last') {
+        const messages = this.db.prepare(
+          'SELECT raw_data FROM messages WHERE conversation_id = ? ORDER BY message_index'
+        ).all(conv.id);
+
+        if (messages.length > 0) {
+          const firstMsg = JSON.parse(messages[0].raw_data);
+          const lastMsg = JSON.parse(messages[messages.length - 1].raw_data);
+
+          formatted.summary = {
+            first_message: firstMsg.content?.substring(0, 100) || '',
+            last_message: lastMsg.content?.substring(0, 100) || '',
+            message_count: messages.length
+          };
+        }
+      }
+
+      return formatted;
+    });
+  }
+
+  /**
+   * Auto-migrate conversations from a folder (PRO - requires license)
+   */
+  migrateFolder(folderPath, options = {}) {
+    this._requirePro('migrateFolder');
+
+    const {
+      backupAfterImport = true,
+      backupPath = null
+    } = options;
+
+    if (!fs.existsSync(folderPath)) {
+      throw new Error(`Folder not found: ${folderPath}`);
+    }
+
+    const files = fs.readdirSync(folderPath);
+    let successCount = 0;
+    let errorCount = 0;
+
+    console.log(`Found ${files.length} files in ${folderPath}\n`);
+
+    for (const file of files) {
+      if (!file.endsWith('.json')) continue;
+
+      const filePath = path.join(folderPath, file);
+      const conversationId = path.basename(file, '.json');
+
+      try {
+        const conversationData = JSON.parse(fs.readFileSync(filePath, 'utf8'));
+
+        // Ensure the conversation ID field is set
+        if (!conversationData[this.conversationIdField]) {
+          conversationData[this.conversationIdField] = conversationId;
+        }
+
+        // Save to database
+        this.update(conversationData);
+        console.log(`✅ Imported: ${conversationId}`);
+        successCount++;
+
+        // Backup if enabled
+        if (backupAfterImport) {
+          const destPath = backupPath 
+            ? path.join(backupPath, file)
+            : path.join(folderPath, 'imported', file);
+          
+          fs.mkdirSync(path.dirname(destPath), { recursive: true });
+          fs.renameSync(filePath, destPath);
+        }
+      } catch (err) {
+        console.log(`❌ Error importing ${conversationId}: ${err.message}`);
+        errorCount++;
+      }
+    }
+
+    console.log(`\n========================================`);
+    console.log(`  Migration Complete`);
+    console.log(`========================================`);
+    console.log(`  Success: ${successCount}`);
+    console.log(`  Errors: ${errorCount}`);
+    console.log(`========================================\n`);
+
+    return { successCount, errorCount };
+  }
+
+  /**
+   * Get list of all conversation IDs (FREE - works without license)
+   */
+  listConversations() {
+    return this.db.prepare(
+      'SELECT id, title, created_at, updated_at FROM conversations ORDER BY updated_at DESC'
+    ).all();
+  }
+
+  /**
+   * Get license info
+   */
+  getLicenseInfo() {
+    return this.license.getLicenseInfo();
+  }
+
+  /**
+   * Close the database connection
+   */
+  close() {
+    if (this.db) {
+      this.db.close();
+    }
+  }
+}
+
+module.exports = TXAIDbPro;

package/src/license.js

@@ -0,0 +1,136 @@
+const fs = require('fs');
+const path = require('path');
+
+/**
+ * License validation system for tx-ai-db-pro
+ * 
+ * Token format: XXXX-XXXX-XXXX-XXXX
+ * Block 1: Last 4 digits of payment ID
+ * Block 2: MMYY (payment date)
+ * Block 3: First 4 digits of payment ID
+ * Block 4: Last digit of Block1 + Last digit of Block2 + Last digit of Block3 + Install number (1-4)
+ * 
+ * .license file must contain exactly 4 keys, one per row.
+ * The first key is the active license for this install.
+ */
+
+class LicenseValidator {
+  constructor() {
+    this.licensePath = path.join(process.cwd(), '.license');
+    this.isPro = false;
+    this.licenseData = null;
+  }
+
+  /**
+   * Validate a single license token format
+   */
+  validateTokenFormat(token) {
+    // Check format: XXXX-XXXX-XXXX-XXXX
+    const regex = /^[A-Z0-9]{4}-[A-Z0-9]{4}-[A-Z0-9]{4}-[A-Z0-9]{4}$/;
+    if (!regex.test(token)) {
+      return { valid: false, error: 'Invalid token format. Expected: XXXX-XXXX-XXXX-XXXX' };
+    }
+
+    const parts = token.split('-');
+    const block1 = parts[0];
+    const block2 = parts[1];
+    const block3 = parts[2];
+    const block4 = parts[3];
+
+    // Validate block 4 structure
+    const expectedBlock4 = block1[3] + block2[3] + block3[3];
+    const installNumber = block4[3];
+
+    // Check first 3 characters of block 4
+    if (block4.substring(0, 3) !== expectedBlock4) {
+      return { valid: false, error: 'Invalid token checksum' };
+    }
+
+    // Check install number (1-4)
+    if (!['1', '2', '3', '4'].includes(installNumber)) {
+      return { valid: false, error: 'Invalid install number. Must be 1-4' };
+    }
+
+    return {
+      valid: true,
+      installNumber: parseInt(installNumber),
+      paymentIdLast4: block1,
+      paymentDate: block2,
+      paymentIdFirst4: block3
+    };
+  }
+
+  /**
+   * Load and validate .license file
+   */
+  loadLicense() {
+    if (!fs.existsSync(this.licensePath)) {
+      return { 
+        isPro: false, 
+        error: 'No .license file found. Run "npm run unlock" to activate pro features.' 
+      };
+    }
+
+    const content = fs.readFileSync(this.licensePath, 'utf8');
+    const keys = content.split('\n').map(k => k.trim()).filter(k => k && !k.startsWith('#'));
+
+    if (keys.length !== 4) {
+      return {
+        isPro: false,
+        error: `Invalid license file. Must contain exactly 4 keys (found ${keys.length}). Add all 4 keys you received after payment.`
+      };
+    }
+
+    // Validate all keys
+    const validations = keys.map(key => this.validateTokenFormat(key));
+    const invalidKey = validations.find(v => !v.valid);
+    
+    if (invalidKey) {
+      return { isPro: false, error: invalidKey.error };
+    }
+
+    // First key is the active license
+    const activeKey = keys[0];
+    const activeValidation = validations[0];
+
+    this.isPro = true;
+    this.licenseData = {
+      keys: keys,
+      activeKey: activeKey,
+      installNumber: activeValidation.installNumber,
+      paymentInfo: {
+        last4: activeValidation.paymentIdLast4,
+        date: activeValidation.paymentDate,
+        first4: activeValidation.paymentIdFirst4
+      }
+    };
+
+    return { isPro: true, licenseData: this.licenseData };
+  }
+
+  /**
+   * Check if pro features are unlocked
+   */
+  isProUnlocked() {
+    const result = this.loadLicense();
+    return result.isPro;
+  }
+
+  /**
+   * Get license info (for debugging/display)
+   */
+  getLicenseInfo() {
+    const result = this.loadLicense();
+    if (!result.isPro) {
+      return { isPro: false, message: result.error };
+    }
+    return {
+      isPro: true,
+      installNumber: result.licenseData.installNumber,
+      paymentDate: result.licenseData.paymentInfo.date,
+      keysLoaded: result.licenseData.keys.length
+    };
+  }
+}
+
+module.exports = LicenseValidator;

package/src/postinstall.js

@@ -0,0 +1,17 @@
+console.log(`
+╔═══════════════════════════════════════════════════════════╗
+║                                                           ║
+║   tx-ai-db-pro installed successfully!                  ║
+║                                                           ║
+║   Next steps:                                             ║
+║   1. Run setup: npm run setup                             ║
+║   2. Point to your conversation folder                    ║
+║   3. Auto-import ALL conversations                        ║
+║                                                           ║
+║   ─────────────────────────────────────────────────────   ║
+║                                                           ║
+║   💚 Love this project? Consider sponsoring us!           ║
+║   https://github.com/sponsors/TX-AI-Series                ║
+║                                                           ║
+╚═══════════════════════════════════════════════════════════╝
+`);

package/src/setup-wizard.js

@@ -0,0 +1,144 @@
+const readline = require('readline');
+const fs = require('fs');
+const path = require('path');
+const https = require('https');
+const http = require('http');
+
+const rl = readline.createInterface({
+  input: process.stdin,
+  output: process.stdout
+});
+
+function askQuestion(question) {
+  return new Promise((resolve) => {
+    rl.question(question, (answer) => {
+      resolve(answer.trim());
+    });
+  });
+}
+
+async function fetchSchema(endpoint) {
+  return new Promise((resolve, reject) => {
+    const url = new URL(endpoint);
+    const lib = url.protocol === 'https:' ? https : http;
+    const req = lib.request(url.toString(), { method: 'GET', headers: { 'Accept': 'application/json' } }, (res) => {
+      let data = '';
+      res.on('data', (chunk) => { data += chunk; });
+      res.on('end', () => {
+        try { resolve(JSON.parse(data)); }
+        catch (e) { reject(new Error('Failed to parse JSON response')); }
+      });
+    });
+    req.on('error', reject);
+    req.end();
+  });
+}
+
+function findIdFields(schema, prefix = '') {
+  let idFields = [];
+  if (typeof schema === 'object' && schema !== null) {
+    if (Array.isArray(schema)) {
+      schema.forEach((item, index) => {
+        idFields = idFields.concat(findIdFields(item, `${prefix}[${index}]`));
+      });
+    } else {
+      for (const [key, value] of Object.entries(schema)) {
+        const fullPath = prefix ? `${prefix}.${key}` : key;
+        if (key.toLowerCase().includes('id')) {
+          idFields.push({ field: fullPath, type: typeof value, value: value });
+        }
+        idFields = idFields.concat(findIdFields(value, fullPath));
+      }
+    }
+  }
+  return idFields;
+}
+
+async function runSetupWizard() {
+  console.log('========================================');
+  console.log('  tx-ai-db-pro Setup Wizard');
+  console.log('========================================\n');
+
+  // Step 1: Get SDK/API endpoint
+  console.log('Step 1: SDK/API Configuration');
+  const endpoint = await askQuestion('API Endpoint (or press Enter to skip): ');
+
+  let idFields = [];
+  if (endpoint) {
+    try {
+      console.log('\nFetching schema from API...');
+      const schema = await fetchSchema(endpoint);
+      idFields = findIdFields(schema);
+      console.log(`Found ${idFields.length} fields containing "id":\n`);
+      idFields.forEach((field, index) => {
+        console.log(`  ${index + 1}. ${field.field} (${field.type}) - Example: ${JSON.stringify(field.value).substring(0, 50)}`);
+      });
+    } catch (err) {
+      console.log(`\nFailed to fetch schema: ${err.message}\nUsing default schema...\n`);
+    }
+  }
+
+  if (idFields.length === 0) {
+    idFields = [
+      { field: 'id', type: 'string', value: 'thread_abc123' },
+      { field: 'thread_id', type: 'string', value: 'thread_abc123' },
+      { field: 'conversation_id', type: 'string', value: 'conv_123' },
+      { field: 'session_id', type: 'string', value: 'sess_456' }
+    ];
+    console.log('Default conversation ID fields:');
+    idFields.forEach((field, index) => {
+      console.log(`  ${index + 1}. ${field.field}`);
+    });
+  }
+
+  // Step 2: Select conversation ID field
+  console.log('\nStep 2: Select Conversation ID Field');
+  const selection = await askQuestion(`Enter number (1-${idFields.length}): `);
+  const selectedIndex = parseInt(selection) - 1;
+  const conversationIdField = (selectedIndex >= 0 && selectedIndex < idFields.length) ? idFields[selectedIndex].field : 'id';
+  console.log(`\nSelected: ${conversationIdField}\n`);
+
+  // Step 3: Get conversation folder path
+  console.log('Step 3: Conversation Folder Path');
+  const folderPath = await askQuestion('Path to conversation folder (or press Enter for default ./conversations): ');
+  const finalFolderPath = folderPath || path.join(process.cwd(), 'conversations');
+
+  // Step 4: Create config
+  console.log('\nStep 4: Creating configuration...');
+  const config = {
+    conversationIdField: conversationIdField,
+    dbPath: path.join(process.cwd(), 'pro.db'),
+    folderPath: finalFolderPath,
+    backupAfterImport: true,
+    version: '1.0.0-pro'
+  };
+
+  const configPath = path.join(process.cwd(), 'pro-config.json');
+  fs.writeFileSync(configPath, JSON.stringify(config, null, 2));
+  console.log(`Config saved to: ${configPath}\n`);
+
+  // Step 5: Auto-migrate
+  console.log('Step 5: Auto-Migration');
+  const migrate = await askQuestion('Import all conversations now? (y/n): ');
+  
+  if (migrate.toLowerCase() === 'y') {
+    const TXAIDbPro = require('./index');
+    const db = new TXAIDbPro(config);
+    try {
+      db.migrateFolder(finalFolderPath, { backupAfterImport: true });
+    } catch (err) {
+      console.log(`Migration error: ${err.message}`);
+    }
+    db.close();
+  }
+
+  console.log('\n========================================');
+  console.log('  Setup Complete!');
+  console.log('========================================\n');
+  console.log('Your conversations are now in the database!');
+  console.log('Use db.search(), db.retrieve(), db.update(), db.delete() in your code.\n');
+
+  rl.close();
+}
+
+runSetupWizard().catch(console.error);

package/src/unlock.js

@@ -0,0 +1,156 @@
+const fs = require('fs');
+const path = require('path');
+const readline = require('readline');
+const GitHubKeyServer = require('./github-key-server');
+
+const rl = readline.createInterface({
+  input: process.stdin,
+  output: process.stdout
+});
+
+function askQuestion(question) {
+  return new Promise((resolve) => {
+    rl.question(question, (answer) => {
+      resolve(answer.trim());
+    });
+  });
+}
+
+async function unlock() {
+  console.log('========================================');
+  console.log('  tx-ai-db-pro License Unlock');
+  console.log('========================================\n');
+
+  const licensePath = path.join(process.cwd(), '.license');
+  const configPath = path.join(process.cwd(), 'pro-config.json');
+  
+  // Load config for keys URL
+  let config = {};
+  if (fs.existsSync(configPath)) {
+    config = JSON.parse(fs.readFileSync(configPath, 'utf8'));
+  }
+
+  const keyServer = new GitHubKeyServer(config);
+
+  // Check if license file already exists with 4 valid keys
+  if (fs.existsSync(licensePath)) {
+    const existing = fs.readFileSync(licensePath, 'utf8');
+    const keys = existing.split('\n').map(k => k.trim()).filter(k => k && !k.startsWith('#'));
+    
+    if (keys.length === 4 && !keys.some(k => k.startsWith('PENDING'))) {
+      console.log('License file already exists with 4 keys.');
+      console.log('Pro features are already unlocked!\n');
+      rl.close();
+      return;
+    }
+  }
+
+  console.log('Enter your GitHub username to fetch your license key.');
+  console.log('Keys are activated within 48 hours of payment.\n');
+
+  const githubUsername = await askQuestion('GitHub username: ');
+
+  console.log('\nFetching key from GitHub Pages...');
+
+  try {
+    const result = await keyServer.getAvailableKey(githubUsername);
+
+    if (!result.found) {
+      console.log(`\n❌ ${result.message}`);
+      rl.close();
+      process.exit(1);
+    }
+
+    const key = result.key;
+    console.log(`✅ Key received for install #${result.installNumber}`);
+
+    // Load existing license or create new
+    let existingKeys = ['PENDING', 'PENDING', 'PENDING', 'PENDING'];
+    if (fs.existsSync(licensePath)) {
+      const existing = fs.readFileSync(licensePath, 'utf8');
+      existingKeys = existing.split('\n').map(k => k.trim()).filter(k => k && !k.startsWith('#'));
+      while (existingKeys.length < 4) existingKeys.push('PENDING');
+    }
+
+    // Replace the first PENDING key with the new one
+    const pendingIndex = existingKeys.findIndex(k => k.startsWith('PENDING'));
+    if (pendingIndex >= 0) {
+      existingKeys[pendingIndex] = key;
+    } else {
+      existingKeys[result.installNumber - 1] = key;
+    }
+
+    // Write license file
+    fs.writeFileSync(licensePath, existingKeys.join('\n') + '\n');
+    console.log(`\n✅ License saved to: ${licensePath}`);
+    console.log(`Key #${result.installNumber} activated for this install.\n`);
+
+    if (existingKeys.some(k => k.startsWith('PENDING'))) {
+      console.log('To activate remaining keys, run: npm run unlock');
+      console.log('(for each remaining install number)\n');
+    }
+
+    console.log('========================================');
+    console.log('  Unlock Complete!');
+    console.log('========================================\n');
+
+  } catch (error) {
+    console.log(`\nError fetching key: ${error.message}`);
+    console.log('Make sure you have a stable internet connection.');
+  }
+
+  rl.close();
+}
+
+async function returnLicense() {
+  console.log('========================================');
+  console.log('  tx-ai-db-pro License Return (Uninstall)');
+  console.log('========================================\n');
+
+  const licensePath = path.join(process.cwd(), '.license');
+
+  if (!fs.existsSync(licensePath)) {
+    console.log('No license file found.');
+    rl.close();
+    return;
+  }
+
+  const existing = fs.readFileSync(licensePath, 'utf8');
+  const keys = existing.split('\n').map(k => k.trim()).filter(k => k && !k.startsWith('#'));
+
+  if (keys.length === 0) {
+    console.log('No keys found in license file.');
+    rl.close();
+    return;
+  }
+
+  console.log('Current keys:');
+  keys.forEach((key, i) => console.log(`  ${i + 1}. ${key}`));
+  console.log('');
+
+  const keyIndex = await askQuestion('Which key to return? (1-4): ');
+  const index = parseInt(keyIndex) - 1;
+
+  if (index < 0 || index >= keys.length) {
+    console.log('\nInvalid key number.');
+    rl.close();
+    process.exit(1);
+  }
+
+  // Mark key as pending (returned)
+  keys[index] = 'PENDING-RETURNED';
+  fs.writeFileSync(licensePath, keys.join('\n') + '\n');
+
+  console.log(`\n✅ Key #${keyIndex} has been returned.`);
+  console.log('You can now activate it on a different machine.\n');
+
+  rl.close();
+}
+
+// Check command line args
+const action = process.argv[2];
+if (action === 'return') {
+  returnLicense().catch(console.error);
+} else {
+  unlock().catch(console.error);
+}