truss-db-mcp 1.0.0

package/evals/eval-query.ts

@@ -0,0 +1,356 @@
+import Database from 'better-sqlite3';
+import { resolve, dirname } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+
+interface EvalResult {
+  name: string;
+  passed: boolean;
+  details: string;
+}
+
+interface EvalSuite {
+  passed: number;
+  failed: number;
+  results: EvalResult[];
+}
+
+// ── Test Database Setup ─────────────────────────────────────────────
+
+export function createTestDb(): string {
+  const dbPath = resolve(__dirname, 'test.db');
+  const db = new Database(dbPath);
+
+  // Drop existing tables
+  db.exec('DROP TABLE IF EXISTS order_items');
+  db.exec('DROP TABLE IF EXISTS orders');
+  db.exec('DROP TABLE IF EXISTS products');
+  db.exec('DROP TABLE IF EXISTS customers');
+
+  // Create schema
+  db.exec(`
+    CREATE TABLE customers (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      name TEXT NOT NULL,
+      email TEXT UNIQUE NOT NULL,
+      city TEXT,
+      created_at TEXT DEFAULT (datetime('now'))
+    );
+
+    CREATE TABLE products (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      name TEXT NOT NULL,
+      price REAL NOT NULL,
+      category TEXT NOT NULL,
+      stock INTEGER DEFAULT 0
+    );
+
+    CREATE TABLE orders (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      customer_id INTEGER NOT NULL,
+      total REAL NOT NULL,
+      status TEXT DEFAULT 'pending',
+      created_at TEXT DEFAULT (datetime('now')),
+      FOREIGN KEY (customer_id) REFERENCES customers(id)
+    );
+
+    CREATE TABLE order_items (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      order_id INTEGER NOT NULL,
+      product_id INTEGER NOT NULL,
+      quantity INTEGER NOT NULL,
+      price REAL NOT NULL,
+      FOREIGN KEY (order_id) REFERENCES orders(id),
+      FOREIGN KEY (product_id) REFERENCES products(id)
+    );
+
+    CREATE INDEX idx_orders_customer_id ON orders(customer_id);
+    CREATE INDEX idx_orders_status ON orders(status);
+    CREATE INDEX idx_order_items_order_id ON order_items(order_id);
+    CREATE INDEX idx_products_category ON products(category);
+  `);
+
+  // Insert sample data
+  const insertCustomer = db.prepare(
+    'INSERT INTO customers (name, email, city) VALUES (?, ?, ?)'
+  );
+  const insertProduct = db.prepare(
+    'INSERT INTO products (name, price, category, stock) VALUES (?, ?, ?, ?)'
+  );
+  const insertOrder = db.prepare(
+    'INSERT INTO orders (customer_id, total, status, created_at) VALUES (?, ?, ?, ?)'
+  );
+  const insertItem = db.prepare(
+    'INSERT INTO order_items (order_id, product_id, quantity, price) VALUES (?, ?, ?, ?)'
+  );
+
+  // Customers
+  const customers = [
+    ['Alice Johnson', 'alice@example.com', 'New York'],
+    ['Bob Smith', 'bob@example.com', 'San Francisco'],
+    ['Carol White', 'carol@example.com', 'Chicago'],
+    ['David Brown', 'david@example.com', 'New York'],
+    ['Eve Davis', 'eve@example.com', 'San Francisco'],
+  ];
+
+  for (const c of customers) {
+    insertCustomer.run(...c);
+  }
+
+  // Products
+  const products = [
+    ['Laptop', 999.99, 'Electronics', 50],
+    ['Phone', 699.99, 'Electronics', 100],
+    ['Headphones', 149.99, 'Electronics', 200],
+    ['Desk', 299.99, 'Furniture', 30],
+    ['Chair', 199.99, 'Furniture', 45],
+    ['Book: SQL Mastery', 39.99, 'Books', 500],
+    ['Book: Data Science', 49.99, 'Books', 300],
+    ['Monitor', 449.99, 'Electronics', 75],
+  ];
+
+  for (const p of products) {
+    insertProduct.run(...p);
+  }
+
+  // Orders
+  const orders = [
+    [1, 1149.98, 'completed', '2026-01-15 10:00:00'],
+    [2, 699.99, 'completed', '2026-01-20 14:30:00'],
+    [1, 299.99, 'shipped', '2026-02-01 09:15:00'],
+    [3, 189.98, 'completed', '2026-02-10 16:45:00'],
+    [4, 999.99, 'pending', '2026-03-01 11:00:00'],
+    [5, 449.99, 'shipped', '2026-03-10 08:30:00'],
+    [2, 39.99, 'completed', '2026-03-15 13:00:00'],
+    [3, 1149.98, 'pending', '2026-03-20 17:00:00'],
+  ];
+
+  for (const o of orders) {
+    insertOrder.run(...o);
+  }
+
+  // Order items
+  const items = [
+    [1, 1, 1, 999.99],   // Alice: 1 Laptop
+    [1, 3, 1, 149.99],   // Alice: 1 Headphones
+    [2, 2, 1, 699.99],   // Bob: 1 Phone
+    [3, 4, 1, 299.99],   // Alice: 1 Desk
+    [4, 6, 2, 39.99],    // Carol: 2 SQL books
+    [4, 3, 1, 149.99],   // Carol: 1 Headphones (wait, total is 189.98 = 2*39.99 + ... let me fix)
+    [5, 1, 1, 999.99],   // David: 1 Laptop
+    [6, 8, 1, 449.99],   // Eve: 1 Monitor
+    [7, 6, 1, 39.99],    // Bob: 1 SQL book
+    [8, 1, 1, 999.99],   // Carol: 1 Laptop
+    [8, 3, 1, 149.99],   // Carol: 1 Headphones
+  ];
+
+  for (const i of items) {
+    insertItem.run(...i);
+  }
+
+  db.close();
+  return dbPath;
+}
+
+// ── Query Evals ─────────────────────────────────────────────────────
+
+export function runQueryEvals(): EvalSuite {
+  const dbPath = createTestDb();
+  const db = new Database(dbPath, { readonly: true });
+  const results: EvalResult[] = [];
+
+  // Eval 1: Basic SELECT
+  try {
+    const rows = db.prepare('SELECT COUNT(*) as cnt FROM customers').all() as Array<{ cnt: number }>;
+    const count = rows[0].cnt;
+    results.push({
+      name: 'Basic SELECT COUNT(*)',
+      passed: count === 5,
+      details: `Expected 5 customers, got ${count}`,
+    });
+  } catch (err) {
+    results.push({ name: 'Basic SELECT COUNT(*)', passed: false, details: String(err) });
+  }
+
+  // Eval 2: JOIN query
+  try {
+    const rows = db.prepare(`
+      SELECT c.name, COUNT(o.id) as order_count
+      FROM customers c
+      LEFT JOIN orders o ON c.id = o.customer_id
+      GROUP BY c.id
+      ORDER BY order_count DESC
+    `).all() as Array<{ name: string; order_count: number }>;
+
+    const alice = rows.find(r => r.name === 'Alice Johnson');
+    results.push({
+      name: 'JOIN with GROUP BY',
+      passed: alice?.order_count === 2 && rows.length === 5,
+      details: `Alice has ${alice?.order_count} orders (expected 2), total customers: ${rows.length}`,
+    });
+  } catch (err) {
+    results.push({ name: 'JOIN with GROUP BY', passed: false, details: String(err) });
+  }
+
+  // Eval 3: Aggregate query
+  try {
+    const rows = db.prepare(`
+      SELECT category, SUM(stock) as total_stock, AVG(price) as avg_price
+      FROM products
+      GROUP BY category
+      ORDER BY total_stock DESC
+    `).all() as Array<{ category: string; total_stock: number; avg_price: number }>;
+
+    const books = rows.find(r => r.category === 'Books');
+    results.push({
+      name: 'Aggregate with GROUP BY',
+      passed: books?.total_stock === 800 && rows.length === 3,
+      details: `Books stock: ${books?.total_stock} (expected 800), categories: ${rows.length}`,
+    });
+  } catch (err) {
+    results.push({ name: 'Aggregate with GROUP BY', passed: false, details: String(err) });
+  }
+
+  // Eval 4: Subquery
+  try {
+    const rows = db.prepare(`
+      SELECT name FROM customers
+      WHERE id IN (SELECT customer_id FROM orders WHERE status = 'pending')
+      ORDER BY name
+    `).all() as Array<{ name: string }>;
+
+    const names = rows.map(r => r.name);
+    results.push({
+      name: 'Subquery with IN',
+      passed: names.includes('David Brown') && names.includes('Carol White') && names.length === 2,
+      details: `Pending customers: ${names.join(', ')} (expected David Brown, Carol White)`,
+    });
+  } catch (err) {
+    results.push({ name: 'Subquery with IN', passed: false, details: String(err) });
+  }
+
+  // Eval 5: EXPLAIN QUERY PLAN
+  try {
+    const rows = db.prepare(
+      'EXPLAIN QUERY PLAN SELECT * FROM orders WHERE customer_id = 1'
+    ).all() as Array<{ detail: string }>;
+
+    const usesIndex = rows.some(r => r.detail.includes('idx_orders_customer_id'));
+    results.push({
+      name: 'EXPLAIN shows index usage',
+      passed: usesIndex,
+      details: `Index used: ${usesIndex}. Plan: ${rows.map(r => r.detail).join('; ')}`,
+    });
+  } catch (err) {
+    results.push({ name: 'EXPLAIN shows index usage', passed: false, details: String(err) });
+  }
+
+  // Eval 6: Foreign key info
+  try {
+    const fks = db.pragma('foreign_key_list("orders")') as Array<{
+      table: string;
+      from: string;
+      to: string;
+    }>;
+
+    results.push({
+      name: 'Foreign key detection',
+      passed: fks.length === 1 && fks[0].table === 'customers',
+      details: `FKs: ${fks.map(f => `${f.from} -> ${f.table}(${f.to})`).join(', ')}`,
+    });
+  } catch (err) {
+    results.push({ name: 'Foreign key detection', passed: false, details: String(err) });
+  }
+
+  // Eval 7: Write rejection (simulate free tier)
+  try {
+    const writePatterns = [
+      'INSERT INTO customers (name, email) VALUES ("test", "test@test.com")',
+      'UPDATE customers SET name = "test" WHERE id = 1',
+      'DELETE FROM customers WHERE id = 1',
+      'DROP TABLE customers',
+      'ALTER TABLE customers ADD COLUMN phone TEXT',
+      'CREATE TABLE test (id INTEGER)',
+    ];
+
+    const writePattern = /^\s*(INSERT|UPDATE|DELETE|DROP|ALTER|CREATE|TRUNCATE|REPLACE|MERGE)\b/i;
+    const allBlocked = writePatterns.every(sql => writePattern.test(sql));
+
+    results.push({
+      name: 'Write pattern detection',
+      passed: allBlocked,
+      details: `All ${writePatterns.length} write patterns correctly detected: ${allBlocked}`,
+    });
+  } catch (err) {
+    results.push({ name: 'Write pattern detection', passed: false, details: String(err) });
+  }
+
+  // Eval 8: Table listing
+  try {
+    const tables = db.prepare(
+      "SELECT name FROM sqlite_master WHERE type='table' AND name NOT LIKE 'sqlite_%' ORDER BY name"
+    ).all() as Array<{ name: string }>;
+
+    const names = tables.map(t => t.name);
+    const expected = ['customers', 'order_items', 'orders', 'products'];
+    const allPresent = expected.every(n => names.includes(n));
+
+    results.push({
+      name: 'Table listing',
+      passed: allPresent && names.length === 4,
+      details: `Tables: ${names.join(', ')} (expected: ${expected.join(', ')})`,
+    });
+  } catch (err) {
+    results.push({ name: 'Table listing', passed: false, details: String(err) });
+  }
+
+  // Eval 9: Column info via pragma
+  try {
+    const cols = db.pragma('table_info("customers")') as Array<{
+      name: string;
+      type: string;
+      notnull: number;
+      pk: number;
+    }>;
+
+    const idCol = cols.find(c => c.name === 'id');
+    const emailCol = cols.find(c => c.name === 'email');
+
+    results.push({
+      name: 'Column info extraction',
+      passed: idCol?.pk === 1 && emailCol?.notnull === 1 && cols.length === 5,
+      details: `id is PK: ${idCol?.pk === 1}, email NOT NULL: ${emailCol?.notnull === 1}, column count: ${cols.length}`,
+    });
+  } catch (err) {
+    results.push({ name: 'Column info extraction', passed: false, details: String(err) });
+  }
+
+  // Eval 10: CSV export format
+  try {
+    const rows = db.prepare('SELECT name, email FROM customers ORDER BY name LIMIT 2').all() as Array<{
+      name: string;
+      email: string;
+    }>;
+
+    const header = 'name,email';
+    const dataRows = rows.map(r => `${r.name},${r.email}`);
+    const csv = [header, ...dataRows].join('\n');
+
+    const expectedCsv = 'name,email\nAlice Johnson,alice@example.com\nBob Smith,bob@example.com';
+    results.push({
+      name: 'CSV export format',
+      passed: csv === expectedCsv,
+      details: csv === expectedCsv ? 'CSV matches expected format' : `Got: ${csv}`,
+    });
+  } catch (err) {
+    results.push({ name: 'CSV export format', passed: false, details: String(err) });
+  }
+
+  db.close();
+
+  const passed = results.filter(r => r.passed).length;
+  const failed = results.filter(r => !r.passed).length;
+
+  return { passed, failed, results };
+}

package/evals/run-evals.ts

@@ -0,0 +1,36 @@
+import { runQueryEvals } from './eval-query.js';
+
+console.log('========================================');
+console.log('  Database Query MCP -- Evaluation Suite');
+console.log('========================================\n');
+
+// ── Query Evals ─────────────────────────────────────────────────────
+
+console.log('--- Query & Schema Evals ---\n');
+
+const queryResults = runQueryEvals();
+
+for (const r of queryResults.results) {
+  const icon = r.passed ? 'PASS' : 'FAIL';
+  console.log(`  [${icon}] ${r.name}`);
+  console.log(`         ${r.details}`);
+}
+
+console.log(`\n  Query: ${queryResults.passed}/${queryResults.passed + queryResults.failed} passed\n`);
+
+// ── Summary ─────────────────────────────────────────────────────────
+
+const totalPassed = queryResults.passed;
+const totalFailed = queryResults.failed;
+const total = totalPassed + totalFailed;
+
+console.log('========================================');
+console.log(`  TOTAL: ${totalPassed}/${total} passed`);
+
+if (totalFailed > 0) {
+  console.log(`  ${totalFailed} failure(s)`);
+}
+
+console.log('========================================');
+
+process.exit(totalFailed > 0 ? 1 : 0);

package/glama.json

@@ -0,0 +1,4 @@
+{
+  "$schema": "https://glama.ai/mcp/schemas/server.json",
+  "maintainers": ["claw-factory"]
+}

package/package.json

@@ -0,0 +1,47 @@
+{
+  "name": "truss-db-mcp",
+  "version": "1.0.0",
+  "description": "Database query MCP server for Claude Code — SQLite, PostgreSQL, and MySQL with AI-powered query tools",
+  "type": "module",
+  "bin": {
+    "truss-db-mcp": "./dist/index.js"
+  },
+  "scripts": {
+    "build": "tsc",
+    "start": "node dist/index.js",
+    "dev": "tsx src/index.ts",
+    "eval": "tsx evals/run-evals.ts"
+  },
+  "keywords": [
+    "mcp",
+    "database",
+    "sqlite",
+    "postgresql",
+    "mysql",
+    "sql",
+    "query",
+    "claude",
+    "claude-code",
+    "ai"
+  ],
+  "author": "TRUSS",
+  "license": "MIT",
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.12.0",
+    "better-sqlite3": "^11.0.0"
+  },
+  "peerDependencies": {
+    "pg": "^8.12.0",
+    "mysql2": "^3.11.0"
+  },
+  "peerDependenciesMeta": {
+    "pg": { "optional": true },
+    "mysql2": { "optional": true }
+  },
+  "devDependencies": {
+    "typescript": "^5.5.0",
+    "tsx": "^4.19.0",
+    "@types/better-sqlite3": "^7.6.0",
+    "@types/node": "^22.0.0"
+  }
+}

package/smithery.yaml

@@ -0,0 +1,18 @@
+startCommand:
+  type: stdio
+  configSchema:
+    type: object
+    properties:
+      TRUSS_LICENSE_KEY:
+        type: string
+        description: "License key for Pro features (optional)"
+      DATABASE_URL:
+        type: string
+        description: "Database connection URL (postgres:// or mysql://)"
+      ANTHROPIC_API_KEY:
+        type: string
+        description: "API key for AI-powered query features (Pro tier)"
+      OPENAI_API_KEY:
+        type: string
+        description: "Alternative AI API key (Pro tier)"
+    required: []

package/src/index.ts

@@ -0,0 +1,99 @@
+#!/usr/bin/env node
+
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+
+// Tool registrations
+import { registerConnect } from './tools/connect.js';
+import { registerListTables } from './tools/list-tables.js';
+import { registerDescribeTable } from './tools/describe-table.js';
+import { registerQuery } from './tools/query.js';
+import { registerNaturalLanguageQuery } from './tools/natural-language-query.js';
+import { registerOptimizeQuery } from './tools/optimize-query.js';
+import { registerGenerateMigration } from './tools/generate-migration.js';
+import { registerExportData } from './tools/export-data.js';
+
+// Lib
+import { closeConnection } from './lib/connection.js';
+import { getLicenseStatus } from './lib/license.js';
+
+const server = new McpServer({
+  name: 'truss-db-mcp',
+  version: '1.0.0',
+});
+
+// ── Status Tool ─────────────────────────────────────────────────────
+
+server.tool(
+  'db_status',
+  'Check database connection status and license tier.',
+  {},
+  async () => {
+    const license = await getLicenseStatus();
+
+    return {
+      content: [{
+        type: 'text' as const,
+        text: JSON.stringify({
+          license: {
+            tier: license.tier,
+            valid: license.valid,
+            expires_at: license.expiresAt,
+          },
+          ...(license.tier === 'free' ? {
+            upgrade_info: {
+              url: 'https://truss.dev/pricing',
+              price: '$25/mo',
+              pro_features: [
+                'Natural language to SQL (AI-powered)',
+                'Query optimization & EXPLAIN analysis',
+                'Migration generation',
+                'CSV/JSON data export',
+                'Write operations (INSERT/UPDATE/DELETE)',
+                'PostgreSQL & MySQL support',
+              ],
+            },
+          } : {}),
+        }, null, 2),
+      }],
+    };
+  }
+);
+
+// ── Free Tier Tools ─────────────────────────────────────────────────
+
+registerConnect(server);
+registerListTables(server);
+registerDescribeTable(server);
+registerQuery(server);
+
+// ── Pro Tier Tools ──────────────────────────────────────────────────
+
+registerNaturalLanguageQuery(server);
+registerOptimizeQuery(server);
+registerGenerateMigration(server);
+registerExportData(server);
+
+// ── Start Server ────────────────────────────────────────────────────
+
+async function main(): Promise<void> {
+  const transport = new StdioServerTransport();
+
+  // Clean shutdown
+  process.on('SIGINT', () => {
+    closeConnection();
+    process.exit(0);
+  });
+  process.on('SIGTERM', () => {
+    closeConnection();
+    process.exit(0);
+  });
+
+  await server.connect(transport);
+}
+
+main().catch((err) => {
+  console.error('Fatal error starting MCP server:', err);
+  closeConnection();
+  process.exit(1);
+});