tx-ai-db-chat 1.0.0

package/README.md

@@ -0,0 +1,85 @@
+# tx-ai-db-chat
+
+Free chat-focused SQLite wrapper for AI conversations.
+
+**OpenAI API Compatible Format only.**
+
+## Features
+
+- 3 simple operations: retrieve, update, delete
+- Works out of the box
+- Smart upsert logic (conversation_id detection)
+- Manual conversation ID list (one ID per row)
+
+## Installation
+
+```bash
+npm install tx-ai-db-chat
+```
+
+## 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. Database is created
+
+## Usage
+
+### Retrieve Conversation
+Drop a JSON file in `retrieve/` folder with:
+```json
+{
+  "conversation_id": "conv_123"
+}
+```
+
+### Update/Save Conversation
+Drop a JSON file in `update/` folder with:
+```json
+{
+  "conversation_id": "conv_123",
+  "messages": [...]
+}
+```
+
+### Delete Conversation
+Drop a JSON file in `delete/` folder with:
+```json
+{
+  "conversation_id": "conv_123"
+}
+```
+
+## Upgrade to Pro
+
+Want auto-migration of 2,000+ conversations, search, and formatted responses?
+
+Upgrade to **tx-ai-db-pro** ($40 one-time payment):
+```bash
+npm install tx-ai-db-pro
+```
+
+**Pro Features:**
+- Auto-discover and import ALL conversations from a folder
+- Search conversations with customizable response formatting
+- File cleanup/backup after import
+- Setup wizard with auto-migration
+- 4 installations per license
+
+**Unlock Pro Features:**
+1. Install: `npm install tx-ai-db-pro`
+2. Pay $40 to receive 4 license keys
+3. Create a `.license` file with all 4 keys (one per row)
+4. Run: `npm run unlock`
+5. Pro features unlocked!
+
+## Funding
+
+If you find this useful, consider sponsoring: https://github.com/sponsors/TX-AI-Series

package/package.json

@@ -0,0 +1,38 @@
+{
+  "name": "tx-ai-db-chat",
+  "version": "1.0.0",
+  "description": "Free chat-focused SQLite wrapper for AI conversations. OpenAI API Compatible Format only.",
+  "main": "src/index.js",
+  "scripts": {
+    "test": "node tests/test.js",
+    "setup": "node src/setup-wizard.js",
+    "postinstall": "node src/postinstall.js"
+  },
+  "keywords": [
+    "sqlite",
+    "ai",
+    "chat",
+    "conversation",
+    "openai",
+    "database",
+    "file-driven"
+  ],
+  "author": "TX-AI-Series",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/TX-AI-Series/tx-ai-db-chat"
+  },
+  "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/import-conversations.js

@@ -0,0 +1,106 @@
+const TXAIDbChat = require('./index');
+const fs = require('fs');
+const path = require('path');
+
+/**
+ * Import conversations from ID list file
+ */
+async function importConversations() {
+  // Load config
+  const configPath = path.join(process.cwd(), 'chat-config.json');
+  if (!fs.existsSync(configPath)) {
+    console.error('Error: chat-config.json not found. Run "npm run setup" first.');
+    process.exit(1);
+  }
+
+  const config = JSON.parse(fs.readFileSync(configPath, 'utf8'));
+
+  // Load conversation IDs
+  const idListPath = path.join(process.cwd(), 'conversation-ids.txt');
+  if (!fs.existsSync(idListPath)) {
+    console.error('Error: conversation-ids.txt not found. Add your conversation IDs first.');
+    process.exit(1);
+  }
+
+  const idContent = fs.readFileSync(idListPath, 'utf8');
+  const conversationIds = idContent
+    .split('\n')
+    .map(line => line.trim())
+    .filter(line => line && !line.startsWith('#'));
+
+  if (conversationIds.length === 0) {
+    console.log('No conversation IDs found in conversation-ids.txt');
+    process.exit(0);
+  }
+
+  console.log(`Found ${conversationIds.length} conversation IDs to import.\n`);
+
+  // Initialize database
+  const db = new TXAIDbChat({
+    dbPath: config.dbPath,
+    conversationIdField: config.conversationIdField
+  });
+
+  // Import each conversation
+  let successCount = 0;
+  let errorCount = 0;
+
+  for (const convId of conversationIds) {
+    try {
+      // Look for conversation file (named with ID)
+      const possiblePaths = [
+        path.join(config.folderPath, `${convId}.json`),
+        path.join(config.folderPath, convId, 'conversation.json'),
+        path.join(process.cwd(), 'conversations', `${convId}.json`)
+      ];
+
+      let conversationData = null;
+      let foundPath = null;
+
+      for (const filePath of possiblePaths) {
+        if (fs.existsSync(filePath)) {
+          conversationData = JSON.parse(fs.readFileSync(filePath, 'utf8'));
+          foundPath = filePath;
+          break;
+        }
+      }
+
+      if (!conversationData) {
+        console.log(`⚠️  Not found: ${convId}`);
+        errorCount++;
+        continue;
+      }
+
+      // Ensure the conversation ID field is set
+      if (!conversationData[config.conversationIdField]) {
+        conversationData[config.conversationIdField] = convId;
+      }
+
+      // Save to database
+      db.update(conversationData);
+      console.log(`✅ Imported: ${convId}`);
+      successCount++;
+
+      // Optional: move file to backup after import
+      if (foundPath && config.backupAfterImport) {
+        const backupPath = foundPath.replace('/databases/', '/databases/imported/');
+        fs.mkdirSync(path.dirname(backupPath), { recursive: true });
+        fs.renameSync(foundPath, backupPath);
+      }
+    } catch (err) {
+      console.log(`❌ Error importing ${convId}: ${err.message}`);
+      errorCount++;
+    }
+  }
+
+  console.log(`\n========================================`);
+  console.log(`  Import Complete`);
+  console.log(`========================================`);
+  console.log(`  Success: ${successCount}`);
+  console.log(`  Errors: ${errorCount}`);
+  console.log(`========================================\n`);
+
+  db.close();
+}
+
+importConversations().catch(console.error);

package/src/index.js

@@ -0,0 +1,151 @@
+const Database = require('better-sqlite3');
+const path = require('path');
+const fs = require('fs');
+
+class TXAIDbChat {
+  constructor(config = {}) {
+    this.dbPath = config.dbPath || path.join(process.cwd(), 'chat.db');
+    this.conversationIdField = config.conversationIdField || 'id';
+    this.db = null;
+    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,
+        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);
+    `);
+  }
+
+  /**
+   * Retrieve a conversation by ID
+   * @param {string} conversationId - The conversation ID to retrieve
+   * @returns {object|null} - The conversation data or null if not found
+   */
+  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 (smart upsert)
+   * @param {object} conversationData - The conversation data (OpenAI API format)
+   * @returns {boolean} - True if successful
+   */
+  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);
+
+    const tx = this.db.transaction(() => {
+      if (existing) {
+        this.db.prepare(
+          'UPDATE conversations SET raw_data = ?, updated_at = datetime(\'now\') WHERE id = ?'
+        ).run(JSON.stringify(conversationData), conversationId);
+
+        this.db.prepare(
+          'DELETE FROM messages WHERE conversation_id = ?'
+        ).run(conversationId);
+      } else {
+        this.db.prepare(
+          'INSERT INTO conversations (id, raw_data) VALUES (?, ?)'
+        ).run(conversationId, JSON.stringify(conversationData));
+      }
+
+      // 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
+   * @param {string} conversationId - The conversation ID to delete
+   * @returns {boolean} - True if deleted, false if not found
+   */
+  delete(conversationId) {
+    const result = this.db.prepare(
+      'DELETE FROM conversations WHERE id = ?'
+    ).run(conversationId);
+
+    return result.changes > 0;
+  }
+
+  /**
+   * Get list of all conversation IDs
+   * @returns {string[]} - Array of conversation IDs
+   */
+  listConversations() {
+    return this.db.prepare(
+      'SELECT id, created_at, updated_at FROM conversations ORDER BY updated_at DESC'
+    ).all();
+  }
+
+  /**
+   * Close the database connection
+   */
+  close() {
+    if (this.db) {
+      this.db.close();
+    }
+  }
+}
+
+module.exports = TXAIDbChat;

package/src/postinstall.js

@@ -0,0 +1,20 @@
+console.log(`
+╔═══════════════════════════════════════════════════════════╗
+║                                                           ║
+║   tx-ai-db-chat installed successfully!                  ║
+║                                                           ║
+║   Next steps:                                             ║
+║   1. Run setup: npm run setup                             ║
+║   2. Add conversation IDs to conversation-ids.txt         ║
+║   3. Import: node src/import-conversations.js             ║
+║                                                           ║
+║   ─────────────────────────────────────────────────────   ║
+║                                                           ║
+║   💚 Love this project? Consider sponsoring us!           ║
+║   https://github.com/sponsors/TX-AI-Series                ║
+║                                                           ║
+║   Want auto-import for 2,000+ conversations?              ║
+║   Upgrade to tx-ai-db-pro ($40)                           ║
+║                                                           ║
+╚═══════════════════════════════════════════════════════════╝
+`);

package/src/setup-wizard.js

@@ -0,0 +1,186 @@
+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());
+    });
+  });
+}
+
+/**
+ * Fetch schema from SDK/API endpoint
+ */
+async function fetchSchema(endpoint) {
+  return new Promise((resolve, reject) => {
+    const url = new URL(endpoint);
+    const lib = url.protocol === 'https:' ? https : http;
+
+    const options = {
+      method: 'GET',
+      hostname: url.hostname,
+      path: url.pathname + url.search,
+      headers: {
+        'Accept': 'application/json'
+      }
+    };
+
+    const req = lib.request(options, (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();
+  });
+}
+
+/**
+ * Find all fields containing "id" in the schema
+ */
+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;
+}
+
+/**
+ * Main setup wizard
+ */
+async function runSetupWizard() {
+  console.log('========================================');
+  console.log('  tx-ai-db-chat Setup Wizard');
+  console.log('========================================\n');
+
+  // Step 1: Get SDK/API endpoint
+  console.log('Step 1: SDK/API Configuration');
+  console.log('Enter your OpenAI-compatible API endpoint to fetch schema.');
+  console.log('Or press Enter to skip and use default schema.\n');
+
+  const endpoint = await askQuestion('API Endpoint (or press Enter to skip): ');
+
+  let schema = null;
+  let idFields = [];
+
+  if (endpoint) {
+    try {
+      console.log('\nFetching schema from API...');
+      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}`);
+      console.log('Using default schema...\n');
+    }
+  }
+
+  // Default ID fields if no API provided
+  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');
+  console.log('Which field identifies your conversations?\n');
+
+  const selection = await askQuestion(`Enter number (1-${idFields.length}): `);
+  const selectedIndex = parseInt(selection) - 1;
+
+  if (selectedIndex < 0 || selectedIndex >= idFields.length) {
+    console.log('Invalid selection. Using default: id');
+    idFields[0];
+  }
+
+  const conversationIdField = idFields[selectedIndex].field;
+  console.log(`\nSelected: ${conversationIdField}\n`);
+
+  // Step 3: Create config file
+  console.log('Step 3: Creating configuration...');
+
+  const config = {
+    conversationIdField: conversationIdField,
+    dbPath: path.join(process.cwd(), 'chat.db'),
+    folderPath: path.join(process.cwd(), 'databases'),
+    version: '1.0.0'
+  };
+
+  const configPath = path.join(process.cwd(), 'chat-config.json');
+  fs.writeFileSync(configPath, JSON.stringify(config, null, 2));
+  console.log(`Config saved to: ${configPath}\n`);
+
+  // Step 4: Create conversation ID list file
+  console.log('Step 4: Create Conversation ID List');
+  console.log('Create a file with one conversation ID per line:');
+  console.log(`  ${path.join(process.cwd(), 'conversation-ids.txt')}\n`);
+
+  const idListPath = path.join(process.cwd(), 'conversation-ids.txt');
+  if (!fs.existsSync(idListPath)) {
+    fs.writeFileSync(idListPath, '# Add your conversation IDs here, one per line\n# Example:\n# conv_123\n# conv_456\n');
+    console.log(`Created empty ID list file: ${idListPath}`);
+  }
+
+  // Step 5: Upgrade prompt
+  console.log('\n========================================');
+  console.log('  Setup Complete!');
+  console.log('========================================\n');
+  console.log('To import conversations:');
+  console.log(`  1. Add conversation IDs to: ${idListPath}`);
+  console.log('  2. Run: node src/import-conversations.js\n');
+  console.log('Want to auto-import 2,000+ conversations?');
+  console.log('Upgrade to tx-ai-db-pro ($40): https://github.com/sponsors/TX-AI-Series\n');
+
+  rl.close();
+}
+
+// Run the wizard
+runSetupWizard().catch(console.error);