@hasna/contacts 0.1.0

package/dist/mcp/index.js

@@ -0,0 +1,1875 @@
+#!/usr/bin/env bun
+// @bun
+
+// src/mcp/index.ts
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import {
+  CallToolRequestSchema,
+  ListToolsRequestSchema
+} from "@modelcontextprotocol/sdk/types.js";
+
+// src/db/database.ts
+import { Database } from "bun:sqlite";
+import { existsSync, mkdirSync } from "fs";
+import { dirname, join, resolve } from "path";
+function getDbPath() {
+  if (process.env["CONTACTS_DB_PATH"])
+    return process.env["CONTACTS_DB_PATH"];
+  const home = process.env["HOME"] || "~";
+  return join(home, ".contacts", "contacts.db");
+}
+function ensureDir(filePath) {
+  if (filePath === ":memory:")
+    return;
+  const dir = dirname(resolve(filePath));
+  if (!existsSync(dir))
+    mkdirSync(dir, { recursive: true });
+}
+var MIGRATIONS = [
+  `
+  CREATE TABLE IF NOT EXISTS companies (
+    id TEXT PRIMARY KEY,
+    name TEXT NOT NULL,
+    domain TEXT,
+    logo_url TEXT,
+    description TEXT,
+    industry TEXT,
+    size TEXT,
+    founded_year INTEGER,
+    notes TEXT,
+    custom_fields TEXT NOT NULL DEFAULT '{}',
+    created_at TEXT NOT NULL DEFAULT (datetime('now')),
+    updated_at TEXT NOT NULL DEFAULT (datetime('now'))
+  );
+
+  CREATE TABLE IF NOT EXISTS contacts (
+    id TEXT PRIMARY KEY,
+    first_name TEXT NOT NULL DEFAULT '',
+    last_name TEXT NOT NULL DEFAULT '',
+    display_name TEXT NOT NULL,
+    nickname TEXT,
+    avatar_url TEXT,
+    notes TEXT,
+    birthday TEXT,
+    company_id TEXT REFERENCES companies(id) ON DELETE SET NULL,
+    job_title TEXT,
+    source TEXT NOT NULL DEFAULT 'manual',
+    custom_fields TEXT NOT NULL DEFAULT '{}',
+    created_at TEXT NOT NULL DEFAULT (datetime('now')),
+    updated_at TEXT NOT NULL DEFAULT (datetime('now'))
+  );
+
+  CREATE TABLE IF NOT EXISTS tags (
+    id TEXT PRIMARY KEY,
+    name TEXT NOT NULL UNIQUE,
+    color TEXT NOT NULL DEFAULT '#6366f1',
+    description TEXT,
+    created_at TEXT NOT NULL DEFAULT (datetime('now'))
+  );
+
+  CREATE TABLE IF NOT EXISTS contact_tags (
+    contact_id TEXT NOT NULL REFERENCES contacts(id) ON DELETE CASCADE,
+    tag_id TEXT NOT NULL REFERENCES tags(id) ON DELETE CASCADE,
+    PRIMARY KEY (contact_id, tag_id)
+  );
+
+  CREATE TABLE IF NOT EXISTS company_tags (
+    company_id TEXT NOT NULL REFERENCES companies(id) ON DELETE CASCADE,
+    tag_id TEXT NOT NULL REFERENCES tags(id) ON DELETE CASCADE,
+    PRIMARY KEY (company_id, tag_id)
+  );
+
+  CREATE TABLE IF NOT EXISTS emails (
+    id TEXT PRIMARY KEY,
+    contact_id TEXT REFERENCES contacts(id) ON DELETE CASCADE,
+    company_id TEXT REFERENCES companies(id) ON DELETE CASCADE,
+    address TEXT NOT NULL,
+    type TEXT NOT NULL DEFAULT 'work' CHECK(type IN ('work','personal','other')),
+    is_primary INTEGER NOT NULL DEFAULT 0,
+    created_at TEXT NOT NULL DEFAULT (datetime('now'))
+  );
+
+  CREATE TABLE IF NOT EXISTS phones (
+    id TEXT PRIMARY KEY,
+    contact_id TEXT REFERENCES contacts(id) ON DELETE CASCADE,
+    company_id TEXT REFERENCES companies(id) ON DELETE CASCADE,
+    number TEXT NOT NULL,
+    country_code TEXT,
+    type TEXT NOT NULL DEFAULT 'mobile' CHECK(type IN ('mobile','work','home','fax','whatsapp','other')),
+    is_primary INTEGER NOT NULL DEFAULT 0,
+    created_at TEXT NOT NULL DEFAULT (datetime('now'))
+  );
+
+  CREATE TABLE IF NOT EXISTS addresses (
+    id TEXT PRIMARY KEY,
+    contact_id TEXT REFERENCES contacts(id) ON DELETE CASCADE,
+    company_id TEXT REFERENCES companies(id) ON DELETE CASCADE,
+    type TEXT NOT NULL DEFAULT 'physical' CHECK(type IN ('physical','mailing','billing','virtual','other')),
+    street TEXT,
+    city TEXT,
+    state TEXT,
+    zip TEXT,
+    country TEXT,
+    is_primary INTEGER NOT NULL DEFAULT 0,
+    created_at TEXT NOT NULL DEFAULT (datetime('now'))
+  );
+
+  CREATE TABLE IF NOT EXISTS social_profiles (
+    id TEXT PRIMARY KEY,
+    contact_id TEXT REFERENCES contacts(id) ON DELETE CASCADE,
+    company_id TEXT REFERENCES companies(id) ON DELETE CASCADE,
+    platform TEXT NOT NULL CHECK(platform IN ('twitter','linkedin','github','instagram','telegram','discord','youtube','tiktok','bluesky','facebook','whatsapp','snapchat','reddit','other')),
+    handle TEXT,
+    url TEXT,
+    is_primary INTEGER NOT NULL DEFAULT 0,
+    created_at TEXT NOT NULL DEFAULT (datetime('now'))
+  );
+
+  CREATE TABLE IF NOT EXISTS contact_relationships (
+    id TEXT PRIMARY KEY,
+    contact_a_id TEXT NOT NULL REFERENCES contacts(id) ON DELETE CASCADE,
+    contact_b_id TEXT NOT NULL REFERENCES contacts(id) ON DELETE CASCADE,
+    relationship_type TEXT NOT NULL CHECK(relationship_type IN ('colleague','friend','family','reports_to','mentor','investor','partner','client','vendor','other')),
+    notes TEXT,
+    created_at TEXT NOT NULL DEFAULT (datetime('now'))
+  );
+
+  CREATE TABLE IF NOT EXISTS activity_log (
+    id TEXT PRIMARY KEY,
+    contact_id TEXT REFERENCES contacts(id) ON DELETE CASCADE,
+    company_id TEXT REFERENCES companies(id) ON DELETE CASCADE,
+    action TEXT NOT NULL,
+    details TEXT,
+    created_at TEXT NOT NULL DEFAULT (datetime('now'))
+  );
+
+  CREATE TABLE IF NOT EXISTS webhooks (
+    id TEXT PRIMARY KEY,
+    url TEXT NOT NULL,
+    events TEXT NOT NULL DEFAULT '["*"]',
+    secret TEXT,
+    active INTEGER NOT NULL DEFAULT 1,
+    created_at TEXT NOT NULL DEFAULT (datetime('now'))
+  );
+
+  CREATE VIRTUAL TABLE IF NOT EXISTS contacts_fts USING fts5(
+    id UNINDEXED,
+    display_name,
+    first_name,
+    last_name,
+    nickname,
+    notes,
+    job_title,
+    content='contacts',
+    content_rowid='rowid'
+  );
+
+  CREATE TRIGGER IF NOT EXISTS contacts_fts_insert AFTER INSERT ON contacts BEGIN
+    INSERT INTO contacts_fts(rowid, id, display_name, first_name, last_name, nickname, notes, job_title)
+    VALUES (new.rowid, new.id, new.display_name, new.first_name, new.last_name, new.nickname, new.notes, new.job_title);
+  END;
+
+  CREATE TRIGGER IF NOT EXISTS contacts_fts_update AFTER UPDATE ON contacts BEGIN
+    DELETE FROM contacts_fts WHERE rowid = old.rowid;
+    INSERT INTO contacts_fts(rowid, id, display_name, first_name, last_name, nickname, notes, job_title)
+    VALUES (new.rowid, new.id, new.display_name, new.first_name, new.last_name, new.nickname, new.notes, new.job_title);
+  END;
+
+  CREATE TRIGGER IF NOT EXISTS contacts_fts_delete AFTER DELETE ON contacts BEGIN
+    DELETE FROM contacts_fts WHERE rowid = old.rowid;
+  END;
+
+  CREATE TABLE IF NOT EXISTS _migrations (version INTEGER PRIMARY KEY);
+  `
+];
+var _db = null;
+function getDatabase(path) {
+  if (_db)
+    return _db;
+  const dbPath = path || getDbPath();
+  ensureDir(dbPath);
+  const db = new Database(dbPath, { create: true });
+  db.exec("PRAGMA journal_mode=WAL");
+  db.exec("PRAGMA foreign_keys=ON");
+  runMigrations(db);
+  _db = db;
+  return db;
+}
+function uuid() {
+  return crypto.randomUUID();
+}
+function now() {
+  return new Date().toISOString();
+}
+function runMigrations(db) {
+  try {
+    const row = db.query("SELECT MAX(version) as v FROM _migrations").get();
+    const current = row?.v ?? -1;
+    for (let i = current + 1;i < MIGRATIONS.length; i++) {
+      db.exec(MIGRATIONS[i]);
+      db.exec(`INSERT OR REPLACE INTO _migrations(version) VALUES(${i})`);
+    }
+  } catch {
+    for (const m of MIGRATIONS) {
+      try {
+        db.exec(m);
+      } catch {}
+    }
+    try {
+      db.exec(`INSERT OR REPLACE INTO _migrations(version) VALUES(${MIGRATIONS.length - 1})`);
+    } catch {}
+  }
+}
+
+// src/types/index.ts
+class ContactNotFoundError extends Error {
+  constructor(id) {
+    super(`Contact not found: ${id}`);
+    this.name = "ContactNotFoundError";
+  }
+}
+
+class CompanyNotFoundError extends Error {
+  constructor(id) {
+    super(`Company not found: ${id}`);
+    this.name = "CompanyNotFoundError";
+  }
+}
+
+class TagNotFoundError extends Error {
+  constructor(id) {
+    super(`Tag not found: ${id}`);
+    this.name = "TagNotFoundError";
+  }
+}
+
+class DuplicateTagNameError extends Error {
+  constructor(name) {
+    super(`Tag with name already exists: ${name}`);
+    this.name = "DuplicateTagNameError";
+  }
+}
+
+// src/db/activity.ts
+function logActivity(db, input) {
+  const id = uuid();
+  db.run(`INSERT INTO activity_log (id, contact_id, company_id, action, details) VALUES (?, ?, ?, ?, ?)`, [id, input.contact_id ?? null, input.company_id ?? null, input.action, input.details ?? null]);
+  return db.query(`SELECT * FROM activity_log WHERE id = ?`).get(id);
+}
+
+// src/db/contacts.ts
+function rowToContact(row) {
+  return {
+    ...row,
+    source: row.source,
+    custom_fields: JSON.parse(row.custom_fields || "{}")
+  };
+}
+function rowToEmail(row) {
+  return {
+    ...row,
+    type: row.type,
+    is_primary: !!row.is_primary
+  };
+}
+function rowToPhone(row) {
+  return {
+    ...row,
+    type: row.type,
+    is_primary: !!row.is_primary
+  };
+}
+function rowToAddress(row) {
+  return {
+    ...row,
+    type: row.type,
+    is_primary: !!row.is_primary
+  };
+}
+function rowToSocialProfile(row) {
+  return {
+    ...row,
+    platform: row.platform,
+    is_primary: !!row.is_primary
+  };
+}
+function rowToTag(row) {
+  return { ...row };
+}
+function rowToCompany(row) {
+  return {
+    ...row,
+    custom_fields: JSON.parse(row.custom_fields || "{}")
+  };
+}
+function insertEmails(db, contactId, companyId, emails) {
+  for (const e of emails) {
+    db.run(`INSERT INTO emails (id, contact_id, company_id, address, type, is_primary) VALUES (?, ?, ?, ?, ?, ?)`, [uuid(), contactId, companyId, e.address, e.type ?? "work", e.is_primary ? 1 : 0]);
+  }
+}
+function insertPhones(db, contactId, companyId, phones) {
+  for (const p of phones) {
+    db.run(`INSERT INTO phones (id, contact_id, company_id, number, country_code, type, is_primary) VALUES (?, ?, ?, ?, ?, ?, ?)`, [uuid(), contactId, companyId, p.number, p.country_code ?? null, p.type ?? "mobile", p.is_primary ? 1 : 0]);
+  }
+}
+function insertAddresses(db, contactId, companyId, addresses) {
+  for (const a of addresses) {
+    db.run(`INSERT INTO addresses (id, contact_id, company_id, type, street, city, state, zip, country, is_primary) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`, [uuid(), contactId, companyId, a.type ?? "physical", a.street ?? null, a.city ?? null, a.state ?? null, a.zip ?? null, a.country ?? null, a.is_primary ? 1 : 0]);
+  }
+}
+function insertSocialProfiles(db, contactId, companyId, profiles) {
+  for (const s of profiles) {
+    db.run(`INSERT INTO social_profiles (id, contact_id, company_id, platform, handle, url, is_primary) VALUES (?, ?, ?, ?, ?, ?, ?)`, [uuid(), contactId, companyId, s.platform, s.handle ?? null, s.url ?? null, s.is_primary ? 1 : 0]);
+  }
+}
+function loadContactDetails(db, contact) {
+  const emails = db.query(`SELECT * FROM emails WHERE contact_id = ?`).all(contact.id).map(rowToEmail);
+  const phones = db.query(`SELECT * FROM phones WHERE contact_id = ?`).all(contact.id).map(rowToPhone);
+  const addresses = db.query(`SELECT * FROM addresses WHERE contact_id = ?`).all(contact.id).map(rowToAddress);
+  const social_profiles = db.query(`SELECT * FROM social_profiles WHERE contact_id = ?`).all(contact.id).map(rowToSocialProfile);
+  const tags = db.query(`
+    SELECT t.* FROM tags t
+    JOIN contact_tags ct ON ct.tag_id = t.id
+    WHERE ct.contact_id = ?
+  `).all(contact.id).map(rowToTag);
+  const companyRow = contact.company_id ? db.query(`SELECT * FROM companies WHERE id = ?`).get(contact.company_id) : null;
+  const company = companyRow ? rowToCompany(companyRow) : null;
+  return { ...contact, emails, phones, addresses, social_profiles, tags, company };
+}
+function createContact(input, db) {
+  const d = db || getDatabase();
+  const id = uuid();
+  const timestamp = now();
+  const firstName = input.first_name ?? "";
+  const lastName = input.last_name ?? "";
+  const displayName = input.display_name ?? (firstName || lastName ? `${firstName} ${lastName}`.trim() : "Unnamed Contact");
+  d.run(`INSERT INTO contacts (id, first_name, last_name, display_name, nickname, avatar_url, notes, birthday, company_id, job_title, source, custom_fields, created_at, updated_at)
+     VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`, [
+    id,
+    firstName,
+    lastName,
+    displayName,
+    input.nickname ?? null,
+    input.avatar_url ?? null,
+    input.notes ?? null,
+    input.birthday ?? null,
+    input.company_id ?? null,
+    input.job_title ?? null,
+    input.source ?? "manual",
+    JSON.stringify(input.custom_fields ?? {}),
+    timestamp,
+    timestamp
+  ]);
+  if (input.emails?.length)
+    insertEmails(d, id, null, input.emails);
+  if (input.phones?.length)
+    insertPhones(d, id, null, input.phones);
+  if (input.addresses?.length)
+    insertAddresses(d, id, null, input.addresses);
+  if (input.social_profiles?.length)
+    insertSocialProfiles(d, id, null, input.social_profiles);
+  if (input.tag_ids?.length) {
+    for (const tagId of input.tag_ids) {
+      d.run(`INSERT OR IGNORE INTO contact_tags (contact_id, tag_id) VALUES (?, ?)`, [id, tagId]);
+    }
+  }
+  logActivity(d, { contact_id: id, action: "contact.created", details: `Created contact: ${displayName}` });
+  const row = d.query(`SELECT * FROM contacts WHERE id = ?`).get(id);
+  return loadContactDetails(d, rowToContact(row));
+}
+function getContact(id, db) {
+  const d = db || getDatabase();
+  const row = d.query(`SELECT * FROM contacts WHERE id = ?`).get(id);
+  if (!row)
+    throw new ContactNotFoundError(id);
+  return loadContactDetails(d, rowToContact(row));
+}
+function listContacts(opts = {}, db) {
+  const d = db || getDatabase();
+  const {
+    limit = 50,
+    offset = 0,
+    company_id,
+    tag_id,
+    source,
+    order_by = "display_name",
+    order_dir = "asc"
+  } = opts;
+  const conditions = [];
+  const params = [];
+  if (company_id) {
+    conditions.push("c.company_id = ?");
+    params.push(company_id);
+  }
+  if (source) {
+    conditions.push("c.source = ?");
+    params.push(source);
+  }
+  if (tag_id) {
+    conditions.push("EXISTS (SELECT 1 FROM contact_tags ct WHERE ct.contact_id = c.id AND ct.tag_id = ?)");
+    params.push(tag_id);
+  }
+  const where = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
+  const validOrderBy = ["display_name", "created_at", "updated_at"].includes(order_by) ? order_by : "display_name";
+  const validOrderDir = order_dir === "desc" ? "DESC" : "ASC";
+  const totalRow = d.query(`SELECT COUNT(*) as total FROM contacts c ${where}`).get(...params);
+  const rows = d.query(`SELECT c.* FROM contacts c ${where} ORDER BY c.${validOrderBy} ${validOrderDir} LIMIT ? OFFSET ?`).all(...params, limit, offset);
+  const contacts = rows.map((row) => loadContactDetails(d, rowToContact(row)));
+  return { contacts, total: totalRow.total };
+}
+function updateContact(id, input, db) {
+  const d = db || getDatabase();
+  const existing = d.query(`SELECT * FROM contacts WHERE id = ?`).get(id);
+  if (!existing)
+    throw new ContactNotFoundError(id);
+  const setClauses = ["updated_at = ?"];
+  const params = [now()];
+  if (input.first_name !== undefined) {
+    setClauses.push("first_name = ?");
+    params.push(input.first_name);
+  }
+  if (input.last_name !== undefined) {
+    setClauses.push("last_name = ?");
+    params.push(input.last_name);
+  }
+  if (input.display_name !== undefined) {
+    setClauses.push("display_name = ?");
+    params.push(input.display_name);
+  }
+  if (input.nickname !== undefined) {
+    setClauses.push("nickname = ?");
+    params.push(input.nickname);
+  }
+  if (input.avatar_url !== undefined) {
+    setClauses.push("avatar_url = ?");
+    params.push(input.avatar_url);
+  }
+  if (input.notes !== undefined) {
+    setClauses.push("notes = ?");
+    params.push(input.notes);
+  }
+  if (input.birthday !== undefined) {
+    setClauses.push("birthday = ?");
+    params.push(input.birthday);
+  }
+  if (input.company_id !== undefined) {
+    setClauses.push("company_id = ?");
+    params.push(input.company_id);
+  }
+  if (input.job_title !== undefined) {
+    setClauses.push("job_title = ?");
+    params.push(input.job_title);
+  }
+  if (input.source !== undefined) {
+    setClauses.push("source = ?");
+    params.push(input.source);
+  }
+  if (input.custom_fields !== undefined) {
+    setClauses.push("custom_fields = ?");
+    params.push(JSON.stringify(input.custom_fields));
+  }
+  params.push(id);
+  d.run(`UPDATE contacts SET ${setClauses.join(", ")} WHERE id = ?`, params);
+  logActivity(d, { contact_id: id, action: "contact.updated", details: `Updated contact: ${existing.display_name}` });
+  const row = d.query(`SELECT * FROM contacts WHERE id = ?`).get(id);
+  return loadContactDetails(d, rowToContact(row));
+}
+function deleteContact(id, db) {
+  const d = db || getDatabase();
+  const row = d.query(`SELECT * FROM contacts WHERE id = ?`).get(id);
+  if (!row)
+    throw new ContactNotFoundError(id);
+  logActivity(d, { contact_id: id, action: "contact.deleted", details: `Deleted contact: ${row.display_name}` });
+  d.run(`DELETE FROM contacts WHERE id = ?`, [id]);
+}
+function searchContacts(query, db) {
+  const d = db || getDatabase();
+  const ftsRows = d.query(`
+    SELECT c.* FROM contacts c
+    JOIN contacts_fts fts ON fts.id = c.id
+    WHERE contacts_fts MATCH ?
+    ORDER BY rank
+    LIMIT 50
+  `).all(`"${query.replace(/"/g, '""')}"*`);
+  const emailRows = d.query(`
+    SELECT DISTINCT c.* FROM contacts c
+    JOIN emails e ON e.contact_id = c.id
+    WHERE e.address LIKE ?
+    LIMIT 20
+  `).all(`%${query}%`);
+  const phoneRows = d.query(`
+    SELECT DISTINCT c.* FROM contacts c
+    JOIN phones p ON p.contact_id = c.id
+    WHERE p.number LIKE ?
+    LIMIT 20
+  `).all(`%${query}%`);
+  const seen = new Set;
+  const allRows = [];
+  for (const row of [...ftsRows, ...emailRows, ...phoneRows]) {
+    if (!seen.has(row.id)) {
+      seen.add(row.id);
+      allRows.push(row);
+    }
+  }
+  return allRows.map((row) => loadContactDetails(d, rowToContact(row)));
+}
+function mergeContacts(keepId, mergeId, db) {
+  const d = db || getDatabase();
+  const keepRow = d.query(`SELECT * FROM contacts WHERE id = ?`).get(keepId);
+  if (!keepRow)
+    throw new ContactNotFoundError(keepId);
+  const mergeRow = d.query(`SELECT * FROM contacts WHERE id = ?`).get(mergeId);
+  if (!mergeRow)
+    throw new ContactNotFoundError(mergeId);
+  d.run(`UPDATE emails SET contact_id = ? WHERE contact_id = ?`, [keepId, mergeId]);
+  d.run(`UPDATE phones SET contact_id = ? WHERE contact_id = ?`, [keepId, mergeId]);
+  d.run(`UPDATE addresses SET contact_id = ? WHERE contact_id = ?`, [keepId, mergeId]);
+  d.run(`UPDATE social_profiles SET contact_id = ? WHERE contact_id = ?`, [keepId, mergeId]);
+  const mergeTags = d.query(`SELECT tag_id FROM contact_tags WHERE contact_id = ?`).all(mergeId);
+  for (const { tag_id } of mergeTags) {
+    d.run(`INSERT OR IGNORE INTO contact_tags (contact_id, tag_id) VALUES (?, ?)`, [keepId, tag_id]);
+  }
+  d.run(`UPDATE contact_relationships SET contact_a_id = ? WHERE contact_a_id = ?`, [keepId, mergeId]);
+  d.run(`UPDATE contact_relationships SET contact_b_id = ? WHERE contact_b_id = ?`, [keepId, mergeId]);
+  d.run(`UPDATE activity_log SET contact_id = ? WHERE contact_id = ?`, [keepId, mergeId]);
+  d.run(`DELETE FROM contacts WHERE id = ?`, [mergeId]);
+  const updates = ["updated_at = ?"];
+  const params = [now()];
+  if (!keepRow.notes && mergeRow.notes) {
+    updates.push("notes = ?");
+    params.push(mergeRow.notes);
+  }
+  if (!keepRow.nickname && mergeRow.nickname) {
+    updates.push("nickname = ?");
+    params.push(mergeRow.nickname);
+  }
+  if (!keepRow.avatar_url && mergeRow.avatar_url) {
+    updates.push("avatar_url = ?");
+    params.push(mergeRow.avatar_url);
+  }
+  if (!keepRow.birthday && mergeRow.birthday) {
+    updates.push("birthday = ?");
+    params.push(mergeRow.birthday);
+  }
+  if (!keepRow.company_id && mergeRow.company_id) {
+    updates.push("company_id = ?");
+    params.push(mergeRow.company_id);
+  }
+  if (!keepRow.job_title && mergeRow.job_title) {
+    updates.push("job_title = ?");
+    params.push(mergeRow.job_title);
+  }
+  params.push(keepId);
+  d.run(`UPDATE contacts SET ${updates.join(", ")} WHERE id = ?`, params);
+  logActivity(d, {
+    contact_id: keepId,
+    action: "contact.merged",
+    details: `Merged contact ${mergeRow.display_name} (${mergeId}) into ${keepRow.display_name} (${keepId})`
+  });
+  const finalRow = d.query(`SELECT * FROM contacts WHERE id = ?`).get(keepId);
+  return loadContactDetails(d, rowToContact(finalRow));
+}
+
+// src/db/companies.ts
+function rowToCompany2(row) {
+  return {
+    ...row,
+    custom_fields: JSON.parse(row.custom_fields || "{}")
+  };
+}
+function insertEmails2(db, companyId, emails) {
+  for (const e of emails) {
+    db.run(`INSERT INTO emails (id, contact_id, company_id, address, type, is_primary) VALUES (?, ?, ?, ?, ?, ?)`, [uuid(), null, companyId, e.address, e.type ?? "work", e.is_primary ? 1 : 0]);
+  }
+}
+function insertPhones2(db, companyId, phones) {
+  for (const p of phones) {
+    db.run(`INSERT INTO phones (id, contact_id, company_id, number, country_code, type, is_primary) VALUES (?, ?, ?, ?, ?, ?, ?)`, [uuid(), null, companyId, p.number, p.country_code ?? null, p.type ?? "work", p.is_primary ? 1 : 0]);
+  }
+}
+function insertAddresses2(db, companyId, addresses) {
+  for (const a of addresses) {
+    db.run(`INSERT INTO addresses (id, contact_id, company_id, type, street, city, state, zip, country, is_primary) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`, [uuid(), null, companyId, a.type ?? "physical", a.street ?? null, a.city ?? null, a.state ?? null, a.zip ?? null, a.country ?? null, a.is_primary ? 1 : 0]);
+  }
+}
+function insertSocialProfiles2(db, companyId, profiles) {
+  for (const s of profiles) {
+    db.run(`INSERT INTO social_profiles (id, contact_id, company_id, platform, handle, url, is_primary) VALUES (?, ?, ?, ?, ?, ?, ?)`, [uuid(), null, companyId, s.platform, s.handle ?? null, s.url ?? null, s.is_primary ? 1 : 0]);
+  }
+}
+function loadCompanyDetails(db, company) {
+  const emails = db.query(`SELECT * FROM emails WHERE company_id = ?`).all(company.id).map((row) => ({
+    ...row,
+    type: row.type,
+    is_primary: !!row.is_primary
+  }));
+  const phones = db.query(`SELECT * FROM phones WHERE company_id = ?`).all(company.id).map((row) => ({
+    ...row,
+    type: row.type,
+    is_primary: !!row.is_primary
+  }));
+  const addresses = db.query(`SELECT * FROM addresses WHERE company_id = ?`).all(company.id).map((row) => ({
+    ...row,
+    type: row.type,
+    is_primary: !!row.is_primary
+  }));
+  const social_profiles = db.query(`SELECT * FROM social_profiles WHERE company_id = ?`).all(company.id).map((row) => ({
+    ...row,
+    platform: row.platform,
+    is_primary: !!row.is_primary
+  }));
+  const tags = db.query(`
+    SELECT t.* FROM tags t
+    JOIN company_tags ct ON ct.tag_id = t.id
+    WHERE ct.company_id = ?
+  `).all(company.id);
+  const empCount = db.query(`SELECT COUNT(*) as count FROM contacts WHERE company_id = ?`).get(company.id);
+  return {
+    ...company,
+    emails,
+    phones,
+    addresses,
+    social_profiles,
+    tags,
+    employee_count: empCount.count
+  };
+}
+function createCompany(input, db) {
+  const d = db || getDatabase();
+  const id = uuid();
+  const timestamp = now();
+  d.run(`INSERT INTO companies (id, name, domain, logo_url, description, industry, size, founded_year, notes, custom_fields, created_at, updated_at)
+     VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`, [
+    id,
+    input.name,
+    input.domain ?? null,
+    input.logo_url ?? null,
+    input.description ?? null,
+    input.industry ?? null,
+    input.size ?? null,
+    input.founded_year ?? null,
+    input.notes ?? null,
+    JSON.stringify(input.custom_fields ?? {}),
+    timestamp,
+    timestamp
+  ]);
+  if (input.emails?.length)
+    insertEmails2(d, id, input.emails);
+  if (input.phones?.length)
+    insertPhones2(d, id, input.phones);
+  if (input.addresses?.length)
+    insertAddresses2(d, id, input.addresses);
+  if (input.social_profiles?.length)
+    insertSocialProfiles2(d, id, input.social_profiles);
+  if (input.tag_ids?.length) {
+    for (const tagId of input.tag_ids) {
+      d.run(`INSERT OR IGNORE INTO company_tags (company_id, tag_id) VALUES (?, ?)`, [id, tagId]);
+    }
+  }
+  logActivity(d, { company_id: id, action: "company.created", details: `Created company: ${input.name}` });
+  const row = d.query(`SELECT * FROM companies WHERE id = ?`).get(id);
+  return loadCompanyDetails(d, rowToCompany2(row));
+}
+function getCompany(id, db) {
+  const d = db || getDatabase();
+  const row = d.query(`SELECT * FROM companies WHERE id = ?`).get(id);
+  if (!row)
+    throw new CompanyNotFoundError(id);
+  return loadCompanyDetails(d, rowToCompany2(row));
+}
+function listCompanies(opts = {}, db) {
+  const d = db || getDatabase();
+  const {
+    limit = 50,
+    offset = 0,
+    industry,
+    tag_id,
+    order_by = "name",
+    order_dir = "asc"
+  } = opts;
+  const conditions = [];
+  const params = [];
+  if (industry) {
+    conditions.push("co.industry = ?");
+    params.push(industry);
+  }
+  if (tag_id) {
+    conditions.push("EXISTS (SELECT 1 FROM company_tags ct WHERE ct.company_id = co.id AND ct.tag_id = ?)");
+    params.push(tag_id);
+  }
+  const where = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
+  const validOrderBy = ["name", "created_at", "updated_at"].includes(order_by) ? order_by : "name";
+  const validOrderDir = order_dir === "desc" ? "DESC" : "ASC";
+  const totalRow = d.query(`SELECT COUNT(*) as total FROM companies co ${where}`).get(...params);
+  const rows = d.query(`SELECT co.* FROM companies co ${where} ORDER BY co.${validOrderBy} ${validOrderDir} LIMIT ? OFFSET ?`).all(...params, limit, offset);
+  const companies = rows.map((row) => loadCompanyDetails(d, rowToCompany2(row)));
+  return { companies, total: totalRow.total };
+}
+function updateCompany(id, input, db) {
+  const d = db || getDatabase();
+  const existing = d.query(`SELECT * FROM companies WHERE id = ?`).get(id);
+  if (!existing)
+    throw new CompanyNotFoundError(id);
+  const setClauses = ["updated_at = ?"];
+  const params = [now()];
+  if (input.name !== undefined) {
+    setClauses.push("name = ?");
+    params.push(input.name);
+  }
+  if (input.domain !== undefined) {
+    setClauses.push("domain = ?");
+    params.push(input.domain);
+  }
+  if (input.logo_url !== undefined) {
+    setClauses.push("logo_url = ?");
+    params.push(input.logo_url);
+  }
+  if (input.description !== undefined) {
+    setClauses.push("description = ?");
+    params.push(input.description);
+  }
+  if (input.industry !== undefined) {
+    setClauses.push("industry = ?");
+    params.push(input.industry);
+  }
+  if (input.size !== undefined) {
+    setClauses.push("size = ?");
+    params.push(input.size);
+  }
+  if (input.founded_year !== undefined) {
+    setClauses.push("founded_year = ?");
+    params.push(input.founded_year);
+  }
+  if (input.notes !== undefined) {
+    setClauses.push("notes = ?");
+    params.push(input.notes);
+  }
+  if (input.custom_fields !== undefined) {
+    setClauses.push("custom_fields = ?");
+    params.push(JSON.stringify(input.custom_fields));
+  }
+  params.push(id);
+  d.run(`UPDATE companies SET ${setClauses.join(", ")} WHERE id = ?`, params);
+  logActivity(d, { company_id: id, action: "company.updated", details: `Updated company: ${existing.name}` });
+  const row = d.query(`SELECT * FROM companies WHERE id = ?`).get(id);
+  return loadCompanyDetails(d, rowToCompany2(row));
+}
+function deleteCompany(id, db) {
+  const d = db || getDatabase();
+  const row = d.query(`SELECT * FROM companies WHERE id = ?`).get(id);
+  if (!row)
+    throw new CompanyNotFoundError(id);
+  logActivity(d, { company_id: id, action: "company.deleted", details: `Deleted company: ${row.name}` });
+  d.run(`DELETE FROM companies WHERE id = ?`, [id]);
+}
+function searchCompanies(query, db) {
+  const d = db || getDatabase();
+  const rows = d.query(`
+    SELECT * FROM companies
+    WHERE name LIKE ? OR domain LIKE ? OR description LIKE ? OR industry LIKE ?
+    LIMIT 50
+  `).all(`%${query}%`, `%${query}%`, `%${query}%`, `%${query}%`);
+  return rows.map((row) => loadCompanyDetails(d, rowToCompany2(row)));
+}
+
+// src/db/tags.ts
+function rowToTag2(row) {
+  return { ...row };
+}
+function createTag(input, db) {
+  const d = db || getDatabase();
+  const existing = d.query(`SELECT id FROM tags WHERE name = ?`).get(input.name);
+  if (existing)
+    throw new DuplicateTagNameError(input.name);
+  const id = uuid();
+  d.run(`INSERT INTO tags (id, name, color, description) VALUES (?, ?, ?, ?)`, [id, input.name, input.color ?? "#6366f1", input.description ?? null]);
+  return rowToTag2(d.query(`SELECT * FROM tags WHERE id = ?`).get(id));
+}
+function listTags(db) {
+  const d = db || getDatabase();
+  return d.query(`SELECT * FROM tags ORDER BY name ASC`).all().map(rowToTag2);
+}
+function deleteTag(id, db) {
+  const d = db || getDatabase();
+  const row = d.query(`SELECT id FROM tags WHERE id = ?`).get(id);
+  if (!row)
+    throw new TagNotFoundError(id);
+  d.run(`DELETE FROM tags WHERE id = ?`, [id]);
+}
+function addTagToContact(contactId, tagId, db) {
+  const d = db || getDatabase();
+  const contact = d.query(`SELECT id FROM contacts WHERE id = ?`).get(contactId);
+  if (!contact)
+    throw new ContactNotFoundError(contactId);
+  const tag = d.query(`SELECT id FROM tags WHERE id = ?`).get(tagId);
+  if (!tag)
+    throw new TagNotFoundError(tagId);
+  d.run(`INSERT OR IGNORE INTO contact_tags (contact_id, tag_id) VALUES (?, ?)`, [contactId, tagId]);
+}
+function removeTagFromContact(contactId, tagId, db) {
+  const d = db || getDatabase();
+  d.run(`DELETE FROM contact_tags WHERE contact_id = ? AND tag_id = ?`, [contactId, tagId]);
+}
+
+// src/db/relationships.ts
+function rowToRelationship(row) {
+  return {
+    ...row,
+    relationship_type: row.relationship_type
+  };
+}
+function createRelationship(input, db) {
+  const d = db || getDatabase();
+  const a = d.query(`SELECT id FROM contacts WHERE id = ?`).get(input.contact_a_id);
+  if (!a)
+    throw new ContactNotFoundError(input.contact_a_id);
+  const b = d.query(`SELECT id FROM contacts WHERE id = ?`).get(input.contact_b_id);
+  if (!b)
+    throw new ContactNotFoundError(input.contact_b_id);
+  const id = uuid();
+  d.run(`INSERT INTO contact_relationships (id, contact_a_id, contact_b_id, relationship_type, notes) VALUES (?, ?, ?, ?, ?)`, [id, input.contact_a_id, input.contact_b_id, input.relationship_type, input.notes ?? null]);
+  return rowToRelationship(d.query(`SELECT * FROM contact_relationships WHERE id = ?`).get(id));
+}
+function listRelationships(opts = {}, db) {
+  const d = db || getDatabase();
+  const { contact_id, relationship_type } = opts;
+  const conditions = [];
+  const params = [];
+  if (contact_id) {
+    conditions.push("(contact_a_id = ? OR contact_b_id = ?)");
+    params.push(contact_id, contact_id);
+  }
+  if (relationship_type) {
+    conditions.push("relationship_type = ?");
+    params.push(relationship_type);
+  }
+  const where = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
+  const rows = d.query(`SELECT * FROM contact_relationships ${where} ORDER BY created_at DESC`).all(...params);
+  return rows.map(rowToRelationship);
+}
+function deleteRelationship(id, db) {
+  const d = db || getDatabase();
+  d.run(`DELETE FROM contact_relationships WHERE id = ?`, [id]);
+}
+
+// src/lib/import.ts
+function parseCsv(text) {
+  const lines = text.split(/\r?\n/);
+  if (lines.length < 2)
+    return [];
+  const headers = parseCsvLine(lines[0]);
+  const rows = [];
+  for (let i = 1;i < lines.length; i++) {
+    const line = lines[i].trim();
+    if (!line)
+      continue;
+    const values = parseCsvLine(line);
+    const row = {};
+    headers.forEach((h, idx) => {
+      row[h.trim()] = values[idx]?.trim() ?? "";
+    });
+    rows.push(row);
+  }
+  return rows;
+}
+function parseCsvLine(line) {
+  const fields = [];
+  let current = "";
+  let inQuotes = false;
+  for (let i = 0;i < line.length; i++) {
+    const ch = line[i];
+    if (ch === '"') {
+      if (inQuotes && line[i + 1] === '"') {
+        current += '"';
+        i++;
+      } else {
+        inQuotes = !inQuotes;
+      }
+    } else if (ch === "," && !inQuotes) {
+      fields.push(current);
+      current = "";
+    } else {
+      current += ch;
+    }
+  }
+  fields.push(current);
+  return fields;
+}
+function csvRowToContact(row) {
+  const firstName = row["First Name"] ?? row["first_name"] ?? row["Given Name"] ?? "";
+  const lastName = row["Last Name"] ?? row["last_name"] ?? row["Family Name"] ?? "";
+  const displayName = row["Name"] ?? row["display_name"] ?? row["Full Name"] ?? [firstName, lastName].filter(Boolean).join(" ") ?? "";
+  if (!displayName && !firstName && !lastName)
+    return null;
+  const contact = {
+    display_name: displayName || [firstName, lastName].filter(Boolean).join(" ") || "Unnamed",
+    first_name: firstName || undefined,
+    last_name: lastName || undefined,
+    job_title: row["Job Title"] ?? row["job_title"] ?? row["Title"] ?? undefined,
+    notes: row["Notes"] ?? row["notes"] ?? undefined,
+    birthday: row["Birthday"] ?? row["birthday"] ?? undefined,
+    source: "import"
+  };
+  const emails = [];
+  for (let i = 1;i <= 5; i++) {
+    const val = row[`Email ${i} - Value`] ?? row[`Email Address ${i}`] ?? (i === 1 ? row["Email"] ?? row["email"] ?? row["Email Address"] : undefined);
+    const rawType = row[`Email ${i} - Type`] ?? (i === 1 ? "work" : "other");
+    if (val) {
+      const type = rawType?.toLowerCase() === "personal" ? "personal" : rawType?.toLowerCase() === "other" ? "other" : "work";
+      emails.push({ address: val, type, is_primary: i === 1 });
+    }
+  }
+  if (emails.length)
+    contact.emails = emails;
+  const phones = [];
+  for (let i = 1;i <= 5; i++) {
+    const val = row[`Phone ${i} - Value`] ?? row[`Phone ${i}`] ?? (i === 1 ? row["Phone"] ?? row["phone"] ?? row["Mobile"] : undefined);
+    const rawType = row[`Phone ${i} - Type`] ?? (i === 1 ? "mobile" : "other");
+    if (val) {
+      const type = rawType?.toLowerCase().includes("mobile") || rawType?.toLowerCase().includes("cell") ? "mobile" : rawType?.toLowerCase().includes("work") ? "work" : rawType?.toLowerCase().includes("home") ? "home" : rawType?.toLowerCase().includes("fax") ? "fax" : "other";
+      phones.push({ number: val, type, is_primary: i === 1 });
+    }
+  }
+  if (phones.length)
+    contact.phones = phones;
+  return contact;
+}
+function importFromCsv(data) {
+  const rows = parseCsv(data);
+  return rows.map(csvRowToContact).filter(Boolean);
+}
+function parseVcf(data) {
+  const contacts = [];
+  const blocks = data.split(/BEGIN:VCARD/i).filter((b) => b.trim());
+  for (const block of blocks) {
+    try {
+      const contact = parseVcfBlock(`BEGIN:VCARD
+` + block);
+      if (contact)
+        contacts.push(contact);
+    } catch {}
+  }
+  return contacts;
+}
+function parseVcfBlock(block) {
+  const unfolded = block.replace(/\r?\n[ \t]/g, "");
+  const lines = unfolded.split(/\r?\n/).filter((l) => l.trim());
+  const contact = { source: "import" };
+  const emails = [];
+  const phones = [];
+  const addresses = [];
+  const socials = [];
+  for (const line of lines) {
+    if (/^BEGIN:VCARD$/i.test(line) || /^END:VCARD$/i.test(line) || /^VERSION:/i.test(line))
+      continue;
+    const colonIdx = line.indexOf(":");
+    if (colonIdx === -1)
+      continue;
+    const propPart = line.slice(0, colonIdx);
+    const value = line.slice(colonIdx + 1).trim();
+    const semicolonIdx = propPart.indexOf(";");
+    const propName = (semicolonIdx === -1 ? propPart : propPart.slice(0, semicolonIdx)).toUpperCase();
+    const params = semicolonIdx !== -1 ? propPart.slice(semicolonIdx + 1) : "";
+    switch (propName) {
+      case "FN":
+        contact.display_name = decodeVcfValue(value);
+        break;
+      case "N": {
+        const parts = value.split(";");
+        contact.last_name = decodeVcfValue(parts[0] ?? "") || undefined;
+        contact.first_name = decodeVcfValue(parts[1] ?? "") || undefined;
+        break;
+      }
+      case "NICKNAME":
+        contact.nickname = decodeVcfValue(value) || undefined;
+        break;
+      case "TITLE":
+        contact.job_title = decodeVcfValue(value) || undefined;
+        break;
+      case "NOTE":
+        contact.notes = decodeVcfValue(value) || undefined;
+        break;
+      case "BDAY":
+        contact.birthday = value.replace(/^(\d{4})(\d{2})(\d{2})$/, "$1-$2-$3");
+        break;
+      case "EMAIL": {
+        const typeMatch = params.match(/TYPE=([^;]+)/i);
+        const rawLabel = typeMatch ? typeMatch[1].toLowerCase() : "work";
+        const type = rawLabel.includes("personal") ? "personal" : rawLabel.includes("other") ? "other" : "work";
+        const isPrimary = params.includes("PREF") || emails.length === 0;
+        emails.push({ address: decodeVcfValue(value), type, is_primary: isPrimary });
+        break;
+      }
+      case "TEL": {
+        const typeMatch = params.match(/TYPE=([^;]+)/i);
+        const rawLabel = typeMatch ? typeMatch[1].toLowerCase() : "mobile";
+        const type = rawLabel.includes("cell") || rawLabel.includes("mobile") ? "mobile" : rawLabel.includes("work") ? "work" : rawLabel.includes("home") ? "home" : rawLabel.includes("fax") ? "fax" : "other";
+        const isPrimary = params.includes("PREF") || phones.length === 0;
+        phones.push({ number: decodeVcfValue(value), type, is_primary: isPrimary });
+        break;
+      }
+      case "ADR": {
+        const parts = value.split(";");
+        const typeMatch = params.match(/TYPE=([^;]+)/i);
+        const rawLabel = typeMatch ? typeMatch[1].toLowerCase().split(",")[0] : "physical";
+        const type = rawLabel.includes("home") || rawLabel.includes("physical") ? "physical" : rawLabel.includes("mail") ? "mailing" : rawLabel.includes("bill") ? "billing" : "other";
+        addresses.push({
+          type,
+          street: decodeVcfValue(parts[2] ?? "") || undefined,
+          city: decodeVcfValue(parts[3] ?? "") || undefined,
+          state: decodeVcfValue(parts[4] ?? "") || undefined,
+          zip: decodeVcfValue(parts[5] ?? "") || undefined,
+          country: decodeVcfValue(parts[6] ?? "") || undefined,
+          is_primary: addresses.length === 0
+        });
+        break;
+      }
+      case "URL": {
+        const url = decodeVcfValue(value);
+        const platform = detectPlatform(url);
+        socials.push({ platform, url, handle: url });
+        break;
+      }
+      case "X-SOCIALPROFILE": {
+        const typeMatch = params.match(/TYPE=([^;]+)/i);
+        const platform = normalizePlatform(typeMatch?.[1] ?? "other");
+        socials.push({ platform, handle: decodeVcfValue(value), url: value });
+        break;
+      }
+    }
+  }
+  if (!contact.display_name) {
+    if (contact.first_name || contact.last_name) {
+      contact.display_name = [contact.first_name, contact.last_name].filter(Boolean).join(" ");
+    } else {
+      return null;
+    }
+  }
+  if (emails.length)
+    contact.emails = emails;
+  if (phones.length)
+    contact.phones = phones;
+  if (addresses.length)
+    contact.addresses = addresses;
+  if (socials.length)
+    contact.social_profiles = socials;
+  return contact;
+}
+function decodeVcfValue(val) {
+  return val.replace(/\\n/g, `
+`).replace(/\\,/g, ",").replace(/\\;/g, ";").replace(/\\\\/g, "\\");
+}
+function detectPlatform(url) {
+  const lower = url.toLowerCase();
+  if (lower.includes("twitter.com") || lower.includes("x.com"))
+    return "twitter";
+  if (lower.includes("linkedin.com"))
+    return "linkedin";
+  if (lower.includes("github.com"))
+    return "github";
+  if (lower.includes("instagram.com"))
+    return "instagram";
+  if (lower.includes("facebook.com"))
+    return "facebook";
+  if (lower.includes("youtube.com"))
+    return "youtube";
+  if (lower.includes("telegram"))
+    return "telegram";
+  if (lower.includes("discord"))
+    return "discord";
+  if (lower.includes("tiktok"))
+    return "tiktok";
+  if (lower.includes("bluesky") || lower.includes("bsky"))
+    return "bluesky";
+  return "other";
+}
+function normalizePlatform(raw) {
+  const lower = raw.toLowerCase();
+  const platforms = [
+    "twitter",
+    "linkedin",
+    "github",
+    "instagram",
+    "telegram",
+    "discord",
+    "youtube",
+    "tiktok",
+    "bluesky",
+    "facebook",
+    "whatsapp",
+    "snapchat",
+    "reddit"
+  ];
+  for (const p of platforms) {
+    if (lower.includes(p))
+      return p;
+  }
+  return "other";
+}
+function importFromJson(data) {
+  let parsed;
+  try {
+    parsed = JSON.parse(data);
+  } catch {
+    throw new Error("Invalid JSON");
+  }
+  if (!Array.isArray(parsed)) {
+    if (typeof parsed === "object" && parsed !== null) {
+      parsed = [parsed];
+    } else {
+      throw new Error("JSON must be an array of contacts");
+    }
+  }
+  return parsed.map((obj) => {
+    const displayName = obj.display_name ?? obj.name ?? [obj.first_name ?? "", obj.last_name ?? ""].filter(Boolean).join(" ") ?? "Unnamed";
+    return {
+      ...obj,
+      display_name: displayName,
+      source: "import"
+    };
+  });
+}
+async function importContacts(format, data) {
+  switch (format) {
+    case "csv":
+      return importFromCsv(data);
+    case "vcf":
+      return parseVcf(data);
+    case "json":
+      return importFromJson(data);
+    default:
+      throw new Error(`Unsupported import format: ${format}`);
+  }
+}
+
+// src/lib/export.ts
+function toJson(contacts) {
+  return JSON.stringify(contacts, null, 2);
+}
+function escapeCsvField(val) {
+  if (val == null)
+    return "";
+  const str = String(val);
+  if (str.includes(",") || str.includes('"') || str.includes(`
+`)) {
+    return `"${str.replace(/"/g, '""')}"`;
+  }
+  return str;
+}
+function toCsv(contacts) {
+  const headers = [
+    "First Name",
+    "Last Name",
+    "Name",
+    "Nickname",
+    "Job Title",
+    "Company",
+    "Email 1 - Value",
+    "Email 1 - Type",
+    "Email 2 - Value",
+    "Email 2 - Type",
+    "Phone 1 - Value",
+    "Phone 1 - Type",
+    "Phone 2 - Value",
+    "Phone 2 - Type",
+    "Address 1 - Street",
+    "Address 1 - City",
+    "Address 1 - State",
+    "Address 1 - Postal Code",
+    "Address 1 - Country",
+    "Address 1 - Type",
+    "Birthday",
+    "Notes",
+    "Tags"
+  ];
+  const rows = [headers.map(escapeCsvField).join(",")];
+  for (const c of contacts) {
+    const emails = c.emails ?? [];
+    const phones = c.phones ?? [];
+    const addrs = c.addresses ?? [];
+    const tags = (c.tags ?? []).map((t) => t.name).join(";");
+    const row = [
+      c.first_name,
+      c.last_name,
+      c.display_name,
+      c.nickname,
+      c.job_title,
+      c.company?.name,
+      emails[0]?.address,
+      emails[0]?.type,
+      emails[1]?.address,
+      emails[1]?.type,
+      phones[0]?.number,
+      phones[0]?.type,
+      phones[1]?.number,
+      phones[1]?.type,
+      addrs[0]?.street,
+      addrs[0]?.city,
+      addrs[0]?.state,
+      addrs[0]?.zip,
+      addrs[0]?.country,
+      addrs[0]?.type,
+      c.birthday,
+      c.notes,
+      tags
+    ];
+    rows.push(row.map(escapeCsvField).join(","));
+  }
+  return rows.join(`
+`);
+}
+function escapeVcfValue(val) {
+  if (!val)
+    return "";
+  return val.replace(/\\/g, "\\\\").replace(/,/g, "\\,").replace(/;/g, "\\;").replace(/\n/g, "\\n");
+}
+function foldVcfLine(line) {
+  if (line.length <= 75)
+    return line;
+  const parts = [line.slice(0, 75)];
+  let i = 75;
+  while (i < line.length) {
+    parts.push(" " + line.slice(i, i + 74));
+    i += 74;
+  }
+  return parts.join(`\r
+`);
+}
+function toVcf(contacts) {
+  const cards = [];
+  for (const c of contacts) {
+    const lines = ["BEGIN:VCARD", "VERSION:3.0"];
+    lines.push(`FN:${escapeVcfValue(c.display_name)}`);
+    lines.push(`N:${escapeVcfValue(c.last_name)};${escapeVcfValue(c.first_name)};;;`);
+    if (c.nickname)
+      lines.push(`NICKNAME:${escapeVcfValue(c.nickname)}`);
+    if (c.job_title)
+      lines.push(`TITLE:${escapeVcfValue(c.job_title)}`);
+    if (c.company?.name)
+      lines.push(`ORG:${escapeVcfValue(c.company.name)}`);
+    if (c.birthday)
+      lines.push(`BDAY:${c.birthday.replace(/-/g, "")}`);
+    for (let i = 0;i < (c.emails ?? []).length; i++) {
+      const e = c.emails[i];
+      const pref = i === 0 || e.is_primary ? ";PREF" : "";
+      lines.push(`EMAIL;TYPE=${e.type.toUpperCase()}${pref}:${escapeVcfValue(e.address)}`);
+    }
+    for (let i = 0;i < (c.phones ?? []).length; i++) {
+      const p = c.phones[i];
+      const pref = i === 0 || p.is_primary ? ";PREF" : "";
+      const vcfType = p.type === "mobile" ? "CELL" : p.type.toUpperCase();
+      lines.push(`TEL;TYPE=${vcfType}${pref}:${escapeVcfValue(p.number)}`);
+    }
+    for (let i = 0;i < (c.addresses ?? []).length; i++) {
+      const a = c.addresses[i];
+      const pref = i === 0 || a.is_primary ? ";PREF" : "";
+      lines.push(`ADR;TYPE=${a.type.toUpperCase()}${pref}:;;${escapeVcfValue(a.street)};${escapeVcfValue(a.city)};${escapeVcfValue(a.state)};${escapeVcfValue(a.zip)};${escapeVcfValue(a.country)}`);
+    }
+    for (const sp of c.social_profiles ?? []) {
+      if (sp.url)
+        lines.push(`URL;TYPE=${sp.platform.toUpperCase()}:${escapeVcfValue(sp.url)}`);
+      if (sp.handle)
+        lines.push(`X-SOCIALPROFILE;TYPE=${sp.platform.toLowerCase()}:${escapeVcfValue(sp.handle)}`);
+    }
+    if (c.notes)
+      lines.push(`NOTE:${escapeVcfValue(c.notes)}`);
+    if (c.tags && c.tags.length > 0) {
+      lines.push(`CATEGORIES:${c.tags.map((t) => escapeVcfValue(t.name)).join(",")}`);
+    }
+    lines.push(`UID:${c.id}`);
+    lines.push("END:VCARD");
+    cards.push(lines.map(foldVcfLine).join(`\r
+`));
+  }
+  return cards.join(`\r
+`);
+}
+async function exportContacts(format, contacts) {
+  switch (format) {
+    case "json":
+      return toJson(contacts);
+    case "csv":
+      return toCsv(contacts);
+    case "vcf":
+      return toVcf(contacts);
+    default:
+      throw new Error(`Unsupported export format: ${format}`);
+  }
+}
+
+// src/mcp/index.ts
+var server = new Server({ name: "contacts", version: "0.1.0" }, { capabilities: { tools: {} } });
+server.setRequestHandler(ListToolsRequestSchema, async () => ({
+  tools: [
+    {
+      name: "create_contact",
+      description: "Create a new contact",
+      inputSchema: {
+        type: "object",
+        properties: {
+          first_name: { type: "string" },
+          last_name: { type: "string" },
+          display_name: { type: "string", description: "Display name" },
+          nickname: { type: "string" },
+          job_title: { type: "string" },
+          company_id: { type: "string" },
+          notes: { type: "string" },
+          birthday: { type: "string", description: "YYYY-MM-DD" },
+          emails: {
+            type: "array",
+            items: {
+              type: "object",
+              properties: {
+                address: { type: "string" },
+                type: { type: "string", enum: ["work", "personal", "other"] },
+                is_primary: { type: "boolean" }
+              },
+              required: ["address"]
+            }
+          },
+          phones: {
+            type: "array",
+            items: {
+              type: "object",
+              properties: {
+                number: { type: "string" },
+                type: { type: "string", enum: ["mobile", "work", "home", "fax", "whatsapp", "other"] },
+                is_primary: { type: "boolean" }
+              },
+              required: ["number"]
+            }
+          },
+          addresses: {
+            type: "array",
+            items: {
+              type: "object",
+              properties: {
+                type: { type: "string", enum: ["physical", "mailing", "billing", "virtual", "other"] },
+                street: { type: "string" },
+                city: { type: "string" },
+                state: { type: "string" },
+                zip: { type: "string" },
+                country: { type: "string" },
+                is_primary: { type: "boolean" }
+              }
+            }
+          },
+          social_profiles: {
+            type: "array",
+            items: {
+              type: "object",
+              properties: {
+                platform: { type: "string", enum: ["twitter", "linkedin", "github", "instagram", "telegram", "discord", "youtube", "tiktok", "bluesky", "facebook", "whatsapp", "snapchat", "reddit", "other"] },
+                handle: { type: "string" },
+                url: { type: "string" },
+                is_primary: { type: "boolean" }
+              },
+              required: ["platform"]
+            }
+          },
+          tag_ids: { type: "array", items: { type: "string" }, description: "Tag IDs to assign" },
+          source: { type: "string" }
+        }
+      }
+    },
+    {
+      name: "get_contact",
+      description: "Get a contact by ID",
+      inputSchema: {
+        type: "object",
+        properties: { id: { type: "string" } },
+        required: ["id"]
+      }
+    },
+    {
+      name: "update_contact",
+      description: "Update an existing contact",
+      inputSchema: {
+        type: "object",
+        properties: {
+          id: { type: "string" },
+          first_name: { type: "string" },
+          last_name: { type: "string" },
+          display_name: { type: "string" },
+          nickname: { type: "string" },
+          job_title: { type: "string" },
+          company_id: { type: "string" },
+          notes: { type: "string" },
+          birthday: { type: "string" }
+        },
+        required: ["id"]
+      }
+    },
+    {
+      name: "delete_contact",
+      description: "Delete a contact by ID",
+      inputSchema: {
+        type: "object",
+        properties: { id: { type: "string" } },
+        required: ["id"]
+      }
+    },
+    {
+      name: "list_contacts",
+      description: "List contacts with optional filters",
+      inputSchema: {
+        type: "object",
+        properties: {
+          company_id: { type: "string" },
+          tag_id: { type: "string", description: "Filter by tag ID" },
+          limit: { type: "number", description: "Max results (default 50)" },
+          offset: { type: "number" },
+          order_by: { type: "string", enum: ["display_name", "created_at", "updated_at"] },
+          order_dir: { type: "string", enum: ["asc", "desc"] }
+        }
+      }
+    },
+    {
+      name: "search_contacts",
+      description: "Full-text search across contacts",
+      inputSchema: {
+        type: "object",
+        properties: { query: { type: "string" } },
+        required: ["query"]
+      }
+    },
+    {
+      name: "create_company",
+      description: "Create a new company",
+      inputSchema: {
+        type: "object",
+        properties: {
+          name: { type: "string" },
+          domain: { type: "string" },
+          description: { type: "string" },
+          industry: { type: "string" },
+          size: { type: "string" },
+          founded_year: { type: "number" },
+          notes: { type: "string" },
+          emails: { type: "array", items: { type: "object" } },
+          phones: { type: "array", items: { type: "object" } },
+          addresses: { type: "array", items: { type: "object" } },
+          social_profiles: { type: "array", items: { type: "object" } },
+          tag_ids: { type: "array", items: { type: "string" } }
+        },
+        required: ["name"]
+      }
+    },
+    {
+      name: "get_company",
+      description: "Get a company by ID",
+      inputSchema: {
+        type: "object",
+        properties: { id: { type: "string" } },
+        required: ["id"]
+      }
+    },
+    {
+      name: "update_company",
+      description: "Update an existing company",
+      inputSchema: {
+        type: "object",
+        properties: {
+          id: { type: "string" },
+          name: { type: "string" },
+          domain: { type: "string" },
+          description: { type: "string" },
+          industry: { type: "string" },
+          size: { type: "string" },
+          founded_year: { type: "number" },
+          notes: { type: "string" }
+        },
+        required: ["id"]
+      }
+    },
+    {
+      name: "delete_company",
+      description: "Delete a company by ID",
+      inputSchema: {
+        type: "object",
+        properties: { id: { type: "string" } },
+        required: ["id"]
+      }
+    },
+    {
+      name: "list_companies",
+      description: "List companies with optional filters",
+      inputSchema: {
+        type: "object",
+        properties: {
+          tag_id: { type: "string" },
+          industry: { type: "string" },
+          limit: { type: "number" },
+          offset: { type: "number" }
+        }
+      }
+    },
+    {
+      name: "search_companies",
+      description: "Search companies by name or domain",
+      inputSchema: {
+        type: "object",
+        properties: { query: { type: "string" } },
+        required: ["query"]
+      }
+    },
+    {
+      name: "create_tag",
+      description: "Create a new tag",
+      inputSchema: {
+        type: "object",
+        properties: {
+          name: { type: "string" },
+          color: { type: "string", description: "Hex color (e.g. #FF5733)" },
+          description: { type: "string" }
+        },
+        required: ["name"]
+      }
+    },
+    {
+      name: "list_tags",
+      description: "List all tags",
+      inputSchema: { type: "object", properties: {} }
+    },
+    {
+      name: "delete_tag",
+      description: "Delete a tag by ID",
+      inputSchema: {
+        type: "object",
+        properties: { id: { type: "string" } },
+        required: ["id"]
+      }
+    },
+    {
+      name: "add_tag_to_contact",
+      description: "Add a tag to a contact",
+      inputSchema: {
+        type: "object",
+        properties: {
+          contact_id: { type: "string" },
+          tag_id: { type: "string" }
+        },
+        required: ["contact_id", "tag_id"]
+      }
+    },
+    {
+      name: "remove_tag_from_contact",
+      description: "Remove a tag from a contact",
+      inputSchema: {
+        type: "object",
+        properties: {
+          contact_id: { type: "string" },
+          tag_id: { type: "string" }
+        },
+        required: ["contact_id", "tag_id"]
+      }
+    },
+    {
+      name: "add_relationship",
+      description: "Add a relationship between two contacts",
+      inputSchema: {
+        type: "object",
+        properties: {
+          contact_a_id: { type: "string" },
+          contact_b_id: { type: "string" },
+          relationship_type: {
+            type: "string",
+            enum: ["colleague", "friend", "family", "reports_to", "mentor", "investor", "partner", "client", "vendor", "other"]
+          },
+          notes: { type: "string" }
+        },
+        required: ["contact_a_id", "contact_b_id", "relationship_type"]
+      }
+    },
+    {
+      name: "list_relationships",
+      description: "List all relationships for a contact",
+      inputSchema: {
+        type: "object",
+        properties: { contact_id: { type: "string" } },
+        required: ["contact_id"]
+      }
+    },
+    {
+      name: "delete_relationship",
+      description: "Delete a relationship by ID",
+      inputSchema: {
+        type: "object",
+        properties: { id: { type: "string" } },
+        required: ["id"]
+      }
+    },
+    {
+      name: "merge_contacts",
+      description: "Merge two contacts \u2014 keeps one, removes the other, merging all data",
+      inputSchema: {
+        type: "object",
+        properties: {
+          keep_id: { type: "string" },
+          merge_id: { type: "string" }
+        },
+        required: ["keep_id", "merge_id"]
+      }
+    },
+    {
+      name: "import_contacts",
+      description: "Import contacts from CSV, vCard, or JSON format",
+      inputSchema: {
+        type: "object",
+        properties: {
+          format: { type: "string", enum: ["json", "csv", "vcf"] },
+          data: { type: "string" }
+        },
+        required: ["format", "data"]
+      }
+    },
+    {
+      name: "export_contacts",
+      description: "Export contacts to CSV, vCard, or JSON format",
+      inputSchema: {
+        type: "object",
+        properties: {
+          format: { type: "string", enum: ["json", "csv", "vcf"] },
+          contact_ids: { type: "array", items: { type: "string" } }
+        },
+        required: ["format"]
+      }
+    },
+    {
+      name: "get_stats",
+      description: "Get database statistics (counts of contacts, companies, tags)",
+      inputSchema: { type: "object", properties: {} }
+    }
+  ]
+}));
+server.setRequestHandler(CallToolRequestSchema, async (request) => {
+  const { name, arguments: args } = request.params;
+  const a = args ?? {};
+  try {
+    switch (name) {
+      case "create_contact": {
+        const input = {
+          first_name: a.first_name,
+          last_name: a.last_name,
+          display_name: a.display_name,
+          nickname: a.nickname,
+          job_title: a.job_title,
+          company_id: a.company_id,
+          notes: a.notes,
+          birthday: a.birthday,
+          emails: a.emails,
+          phones: a.phones,
+          addresses: a.addresses,
+          social_profiles: a.social_profiles,
+          tag_ids: a.tag_ids,
+          source: a.source
+        };
+        const contact = createContact(input);
+        return { content: [{ type: "text", text: JSON.stringify(contact, null, 2) }] };
+      }
+      case "get_contact": {
+        const contact = getContact(a.id);
+        return { content: [{ type: "text", text: JSON.stringify(contact, null, 2) }] };
+      }
+      case "update_contact": {
+        const { id, ...rest } = a;
+        const input = {
+          first_name: rest.first_name,
+          last_name: rest.last_name,
+          display_name: rest.display_name,
+          nickname: rest.nickname,
+          job_title: rest.job_title,
+          company_id: rest.company_id,
+          notes: rest.notes,
+          birthday: rest.birthday
+        };
+        const contact = updateContact(id, input);
+        return { content: [{ type: "text", text: JSON.stringify(contact, null, 2) }] };
+      }
+      case "delete_contact": {
+        deleteContact(a.id);
+        return { content: [{ type: "text", text: `Contact ${a.id} deleted successfully` }] };
+      }
+      case "list_contacts": {
+        const result = listContacts({
+          company_id: a.company_id,
+          tag_id: a.tag_id,
+          limit: a.limit,
+          offset: a.offset,
+          order_by: a.order_by,
+          order_dir: a.order_dir
+        });
+        return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+      }
+      case "search_contacts": {
+        const contacts = searchContacts(a.query);
+        return { content: [{ type: "text", text: JSON.stringify(contacts, null, 2) }] };
+      }
+      case "create_company": {
+        const input = {
+          name: a.name,
+          domain: a.domain,
+          description: a.description,
+          industry: a.industry,
+          size: a.size,
+          founded_year: a.founded_year,
+          notes: a.notes,
+          emails: a.emails,
+          phones: a.phones,
+          addresses: a.addresses,
+          social_profiles: a.social_profiles,
+          tag_ids: a.tag_ids
+        };
+        const company = createCompany(input);
+        return { content: [{ type: "text", text: JSON.stringify(company, null, 2) }] };
+      }
+      case "get_company": {
+        const company = getCompany(a.id);
+        if (!company) {
+          return { content: [{ type: "text", text: `Company not found: ${a.id}` }], isError: true };
+        }
+        return { content: [{ type: "text", text: JSON.stringify(company, null, 2) }] };
+      }
+      case "update_company": {
+        const { id, ...rest } = a;
+        const input = {
+          name: rest.name,
+          domain: rest.domain,
+          description: rest.description,
+          industry: rest.industry,
+          size: rest.size,
+          founded_year: rest.founded_year,
+          notes: rest.notes
+        };
+        const company = updateCompany(id, input);
+        return { content: [{ type: "text", text: JSON.stringify(company, null, 2) }] };
+      }
+      case "delete_company": {
+        deleteCompany(a.id);
+        return { content: [{ type: "text", text: `Company ${a.id} deleted successfully` }] };
+      }
+      case "list_companies": {
+        const result = listCompanies({
+          tag_id: a.tag_id,
+          industry: a.industry,
+          limit: a.limit,
+          offset: a.offset
+        });
+        return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+      }
+      case "search_companies": {
+        const companies = searchCompanies(a.query);
+        return { content: [{ type: "text", text: JSON.stringify(companies, null, 2) }] };
+      }
+      case "create_tag": {
+        const input = {
+          name: a.name,
+          color: a.color,
+          description: a.description
+        };
+        const tag = createTag(input);
+        return { content: [{ type: "text", text: JSON.stringify(tag, null, 2) }] };
+      }
+      case "list_tags": {
+        const tags = listTags();
+        return { content: [{ type: "text", text: JSON.stringify(tags, null, 2) }] };
+      }
+      case "delete_tag": {
+        deleteTag(a.id);
+        return { content: [{ type: "text", text: `Tag ${a.id} deleted successfully` }] };
+      }
+      case "add_tag_to_contact": {
+        addTagToContact(a.contact_id, a.tag_id);
+        return { content: [{ type: "text", text: `Tag ${a.tag_id} added to contact ${a.contact_id}` }] };
+      }
+      case "remove_tag_from_contact": {
+        removeTagFromContact(a.contact_id, a.tag_id);
+        return { content: [{ type: "text", text: `Tag ${a.tag_id} removed from contact ${a.contact_id}` }] };
+      }
+      case "add_relationship": {
+        const input = {
+          contact_a_id: a.contact_a_id,
+          contact_b_id: a.contact_b_id,
+          relationship_type: a.relationship_type,
+          notes: a.notes
+        };
+        const rel = createRelationship(input);
+        return { content: [{ type: "text", text: JSON.stringify(rel, null, 2) }] };
+      }
+      case "list_relationships": {
+        const rels = listRelationships({ contact_id: a.contact_id });
+        return { content: [{ type: "text", text: JSON.stringify(rels, null, 2) }] };
+      }
+      case "delete_relationship": {
+        deleteRelationship(a.id);
+        return { content: [{ type: "text", text: `Relationship ${a.id} deleted successfully` }] };
+      }
+      case "merge_contacts": {
+        const merged = mergeContacts(a.keep_id, a.merge_id);
+        return { content: [{ type: "text", text: JSON.stringify(merged, null, 2) }] };
+      }
+      case "import_contacts": {
+        const format = a.format;
+        const data = a.data;
+        const inputs = await importContacts(format, data);
+        let importedCount = 0;
+        const errors = [];
+        for (const input of inputs) {
+          try {
+            createContact(input);
+            importedCount++;
+          } catch (err) {
+            errors.push(err instanceof Error ? err.message : String(err));
+          }
+        }
+        return {
+          content: [{
+            type: "text",
+            text: JSON.stringify({ imported: importedCount, errors: errors.length, error_details: errors }, null, 2)
+          }]
+        };
+      }
+      case "export_contacts": {
+        const format = a.format;
+        const contactIds = a.contact_ids;
+        let contactList;
+        if (contactIds && contactIds.length > 0) {
+          contactList = contactIds.map((id) => getContact(id));
+        } else {
+          contactList = listContacts({ limit: 1e4 }).contacts;
+        }
+        const output = await exportContacts(format, contactList);
+        return { content: [{ type: "text", text: output }] };
+      }
+      case "get_stats": {
+        const db = getDatabase();
+        const contactCount = db.prepare("SELECT COUNT(*) as count FROM contacts").get().count;
+        const companyCount = db.prepare("SELECT COUNT(*) as count FROM companies").get().count;
+        const tagCount = db.prepare("SELECT COUNT(*) as count FROM tags").get().count;
+        return {
+          content: [{
+            type: "text",
+            text: JSON.stringify({ contacts: contactCount, companies: companyCount, tags: tagCount }, null, 2)
+          }]
+        };
+      }
+      default:
+        return { content: [{ type: "text", text: `Unknown tool: ${name}` }], isError: true };
+    }
+  } catch (err) {
+    return {
+      content: [{ type: "text", text: `Error: ${err instanceof Error ? err.message : String(err)}` }],
+      isError: true
+    };
+  }
+});
+async function main() {
+  const transport = new StdioServerTransport;
+  await server.connect(transport);
+  console.error("Contacts MCP server running on stdio");
+}
+main().catch((err) => {
+  console.error("Fatal error:", err);
+  process.exit(1);
+});