@conversionpros/aiva 1.0.0

package/router-v2/scheduler.js

@@ -0,0 +1,301 @@
+// ── Scheduler - Calendar Booking / Reschedule / Cancel ───
+// Invoked as a tool call from the Conversation Engine.
+'use strict';
+
+const { getStmts, getSetting } = require('./db');
+
+const CALENDAR_BASE = 'http://localhost:3847/api/integrations/google/calendars';
+
+function log(msg, data) {
+  const ts = new Date().toISOString();
+  if (data) console.log(`[${ts}] [SCHEDULER] ${msg}`, JSON.stringify(data));
+  else console.log(`[${ts}] [SCHEDULER] ${msg}`);
+}
+
+/**
+ * Get scheduling rule for a contact category.
+ * @param {string} category
+ * @returns {Object}
+ */
+function getSchedulingRule(category) {
+  const rule = getStmts().getSchedulingRule.get(category);
+  return rule || { category, rule_preset: 'flexible', custom_instructions: '', structured_overrides: '{}' };
+}
+
+/**
+ * Check calendar availability for a given time range.
+ * @param {string} timeMin - ISO datetime start
+ * @param {string} timeMax - ISO datetime end
+ * @param {string} [calendarId='primary'] - Calendar ID
+ * @param {string} [accountId] - Google account ID
+ * @returns {Promise<Array>} List of existing events (conflicts)
+ */
+async function checkAvailability(timeMin, timeMax, calendarId = 'primary', accountId = null) {
+  try {
+    let url = `${CALENDAR_BASE}/${encodeURIComponent(calendarId)}/events?timeMin=${encodeURIComponent(timeMin)}&timeMax=${encodeURIComponent(timeMax)}`;
+    if (accountId) url += `&accountId=${accountId}`;
+
+    const resp = await fetch(url, { signal: AbortSignal.timeout(15000) });
+    if (!resp.ok) {
+      log('Calendar API error', { status: resp.status });
+      return { error: `calendar_api_${resp.status}`, events: null };
+    }
+
+    const data = await resp.json();
+    return { error: null, events: data.events || data.items || data || [] };
+  } catch (err) {
+    log('Calendar check failed', { error: err.message });
+    return { error: err.message, events: null };
+  }
+}
+
+/**
+ * Book an appointment on the calendar.
+ * @param {Object} event
+ * @param {string} event.summary - Event title
+ * @param {string} event.startTime - ISO datetime
+ * @param {string} event.endTime - ISO datetime
+ * @param {string} [event.description] - Event description
+ * @param {string} [event.attendeeEmail] - Attendee email
+ * @param {string} [event.calendarId='primary']
+ * @param {string} [event.accountId]
+ * @returns {Promise<{success: boolean, event?: Object, error?: string}>}
+ */
+async function bookAppointment(event) {
+  const calendarId = event.calendarId || 'primary';
+  const accountId = event.accountId || null;
+
+  // Check for conflicts first
+  const availCheck = await checkAvailability(event.startTime, event.endTime, calendarId, accountId);
+  if (availCheck.error) {
+    log('Cannot verify availability', { error: availCheck.error });
+    return { success: false, error: `Cannot verify calendar availability: ${availCheck.error}. Please try again.` };
+  }
+  if (availCheck.events.length > 0) {
+    const conflictNames = availCheck.events.map(c => c.summary || 'Busy').join(', ');
+    log('Booking conflict', { time: event.startTime, conflicts: conflictNames });
+    return {
+      success: false,
+      error: `Time slot has conflicts: ${conflictNames}`,
+      conflicts: availCheck.events,
+    };
+  }
+
+  try {
+    let url = `${CALENDAR_BASE}/${encodeURIComponent(calendarId)}/events`;
+    if (accountId) url += `?accountId=${accountId}`;
+
+    const body = {
+      summary: event.summary,
+      start: { dateTime: event.startTime },
+      end: { dateTime: event.endTime },
+    };
+    if (event.description) body.description = event.description;
+    if (event.attendeeEmail) body.attendees = [{ email: event.attendeeEmail }];
+
+    const resp = await fetch(url, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify(body),
+      signal: AbortSignal.timeout(15000),
+    });
+
+    if (!resp.ok) {
+      const errText = await resp.text().catch(() => 'unknown');
+      log('Booking failed', { status: resp.status, error: errText.substring(0, 200) });
+      return { success: false, error: `Calendar API error: ${resp.status}` };
+    }
+
+    const created = await resp.json();
+    log('Booking success', { summary: event.summary, start: event.startTime });
+    return { success: true, event: created };
+  } catch (err) {
+    log('Booking error', { error: err.message });
+    return { success: false, error: err.message };
+  }
+}
+
+/**
+ * Find available slots in a date range.
+ * @param {string} dateStr - Date string (e.g. "2026-02-27")
+ * @param {number} [durationMin=30] - Meeting duration in minutes
+ * @param {string} [calendarId='primary']
+ * @param {string} [accountId]
+ * @returns {Promise<Array<{start: string, end: string}>>}
+ */
+async function findAvailableSlots(dateStr, durationMin = 30, calendarId = 'primary', accountId = null) {
+  // Use Intl to get the correct PST/PDT offset for the given date
+  const formatter = new Intl.DateTimeFormat('en-US', { timeZone: 'America/Los_Angeles', timeZoneName: 'shortOffset' });
+  const refDate = new Date(dateStr + 'T12:00:00Z');
+  const parts = formatter.formatToParts(refDate);
+  const tzPart = parts.find(p => p.type === 'timeZoneName')?.value || 'GMT-8';
+  const offsetMatch = tzPart.match(/GMT([+-]\d+)/);
+  const offsetHours = offsetMatch ? parseInt(offsetMatch[1]) : -8;
+  const offsetStr = `${offsetHours >= 0 ? '+' : ''}${String(Math.abs(offsetHours)).padStart(2, '0')}:00`;
+
+  const dayStart = new Date(`${dateStr}T09:00:00${offsetStr}`);
+  const dayEnd = new Date(`${dateStr}T17:00:00${offsetStr}`);
+
+  const availCheck = await checkAvailability(dayStart.toISOString(), dayEnd.toISOString(), calendarId, accountId);
+  if (availCheck.error) return [];
+  const events = availCheck.events;
+
+  // Build busy blocks
+  const busy = events.map(e => ({
+    start: new Date(e.start?.dateTime || e.start).getTime(),
+    end: new Date(e.end?.dateTime || e.end).getTime(),
+  })).sort((a, b) => a.start - b.start);
+
+  // Find gaps
+  const slots = [];
+  const durationMs = durationMin * 60000;
+  let cursor = dayStart.getTime();
+
+  for (const block of busy) {
+    if (block.start - cursor >= durationMs) {
+      slots.push({
+        start: new Date(cursor).toISOString(),
+        end: new Date(cursor + durationMs).toISOString(),
+      });
+    }
+    cursor = Math.max(cursor, block.end);
+  }
+
+  // Check remaining time after last event
+  if (dayEnd.getTime() - cursor >= durationMs) {
+    slots.push({
+      start: new Date(cursor).toISOString(),
+      end: new Date(cursor + durationMs).toISOString(),
+    });
+  }
+
+  return slots;
+}
+
+/**
+ * Reschedule an existing event.
+ * @param {string} eventId - Event ID to reschedule
+ * @param {string} newStart - New ISO start time
+ * @param {string} newEnd - New ISO end time
+ * @param {string} [calendarId='primary']
+ * @param {string} [accountId]
+ * @returns {Promise<{success: boolean, error?: string}>}
+ */
+async function rescheduleAppointment(eventId, newStart, newEnd, calendarId = 'primary', accountId = null) {
+  // Check for conflicts at new time
+  const availCheck = await checkAvailability(newStart, newEnd, calendarId, accountId);
+  if (availCheck.error) {
+    return { success: false, error: `Cannot verify availability: ${availCheck.error}` };
+  }
+  if (availCheck.events.length > 0) {
+    return { success: false, error: 'New time slot has conflicts', conflicts: availCheck.events };
+  }
+
+  try {
+    let url = `${CALENDAR_BASE}/${encodeURIComponent(calendarId)}/events/${encodeURIComponent(eventId)}`;
+    if (accountId) url += `?accountId=${accountId}`;
+
+    const resp = await fetch(url, {
+      method: 'PUT',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({
+        start: { dateTime: newStart },
+        end: { dateTime: newEnd },
+      }),
+      signal: AbortSignal.timeout(15000),
+    });
+
+    if (!resp.ok) return { success: false, error: `Calendar API error: ${resp.status}` };
+    log('Rescheduled', { eventId, newStart });
+    return { success: true };
+  } catch (err) {
+    return { success: false, error: err.message };
+  }
+}
+
+/**
+ * Cancel an existing event.
+ * @param {string} eventId
+ * @param {string} [calendarId='primary']
+ * @param {string} [accountId]
+ * @returns {Promise<{success: boolean, error?: string}>}
+ */
+async function cancelAppointment(eventId, calendarId = 'primary', accountId = null) {
+  try {
+    let url = `${CALENDAR_BASE}/${encodeURIComponent(calendarId)}/events/${encodeURIComponent(eventId)}`;
+    if (accountId) url += `?accountId=${accountId}`;
+
+    const resp = await fetch(url, {
+      method: 'DELETE',
+      signal: AbortSignal.timeout(15000),
+    });
+
+    if (!resp.ok) return { success: false, error: `Calendar API error: ${resp.status}` };
+    log('Cancelled', { eventId });
+    return { success: true };
+  } catch (err) {
+    return { success: false, error: err.message };
+  }
+}
+
+/**
+ * Handle a schedule_appointment tool call from the Conversation Engine.
+ * @param {Object} args - Tool call arguments from Sonnet
+ * @param {Object} contact - Contact record
+ * @returns {Promise<Object>} Result to feed back into conversation
+ */
+async function handleToolCall(args, contact) {
+  const action = args.action || 'book';
+  const accountId = args.accountId || getSetting('calendarAccountId') || null;
+  const calendarId = args.calendarId || 'primary';
+
+  switch (action) {
+    case 'check_availability': {
+      const slots = await findAvailableSlots(args.date, args.duration || 30, calendarId, accountId);
+      if (slots.length === 0) {
+        return { success: false, message: `No available ${args.duration || 30}-minute slots on ${args.date}.` };
+      }
+      return {
+        success: true,
+        message: `Found ${slots.length} available slot(s) on ${args.date}.`,
+        slots: slots.slice(0, 3),
+      };
+    }
+
+    case 'book': {
+      const result = await bookAppointment({
+        summary: args.summary || `Meeting with ${contact.name}`,
+        startTime: args.startTime,
+        endTime: args.endTime,
+        description: args.description || `Booked by AIVA for ${contact.name} (${contact.phone})`,
+        attendeeEmail: args.attendeeEmail || null,
+        calendarId,
+        accountId,
+      });
+      return result;
+    }
+
+    case 'reschedule': {
+      const result = await rescheduleAppointment(args.eventId, args.newStart, args.newEnd, calendarId, accountId);
+      return result;
+    }
+
+    case 'cancel': {
+      const result = await cancelAppointment(args.eventId, calendarId, accountId);
+      return result;
+    }
+
+    default:
+      return { success: false, error: `Unknown scheduling action: ${action}` };
+  }
+}
+
+module.exports = {
+  getSchedulingRule,
+  checkAvailability,
+  bookAppointment,
+  findAvailableSlots,
+  rescheduleAppointment,
+  cancelAppointment,
+  handleToolCall,
+};

package/router-v2/scripts/migrate-v1-to-v2.js

@@ -0,0 +1,215 @@
+#!/usr/bin/env node
+// ── Migrate v1 Database to v2 ────────────────────────────
+// Reads from v1 (data/aiva.db or message-router/router.db), writes to v2.
+// Safe to run multiple times (idempotent). Does NOT modify v1 database.
+'use strict';
+
+const path = require('path');
+const fs = require('fs');
+const Database = require('better-sqlite3');
+
+const V1_PATHS = [
+  path.join(process.env.HOME, '.openclaw', 'workspace', 'message-router', 'router.db'),
+  path.join(__dirname, '..', '..', 'data', 'aiva.db'),
+];
+
+const V2_DIR = path.join(__dirname, '..', 'data');
+const V2_PATH = path.join(V2_DIR, 'router-v2.db');
+
+function log(msg) {
+  console.log(`[MIGRATE] ${msg}`);
+}
+
+function findV1Db() {
+  for (const p of V1_PATHS) {
+    if (fs.existsSync(p)) {
+      log(`Found v1 DB at: ${p}`);
+      return p;
+    }
+  }
+  return null;
+}
+
+function run() {
+  const v1Path = findV1Db();
+  if (!v1Path) {
+    log('No v1 database found. Nothing to migrate.');
+    return;
+  }
+
+  // Initialize v2 DB (this creates tables)
+  const { initDatabase } = require('../db');
+  const { db: v2 } = initDatabase();
+
+  const v1 = new Database(v1Path, { readonly: true });
+  v1.pragma('journal_mode = WAL');
+
+  let migrated = { contacts: 0, context: 0, scopes: 0, messages: 0, settings: 0, followUps: 0, schedulingRules: 0 };
+
+  // ── Migrate contacts (contact_rules -> contacts) ──
+  try {
+    const contacts = v1.prepare('SELECT * FROM contact_rules').all();
+    const upsert = v2.prepare(`
+      INSERT INTO contacts (phone, name, category, response_mode, style, instructions, source, introduced, qualification_score, pipeline_stage, created_at, updated_at)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, 0, 'none', ?, ?)
+      ON CONFLICT(phone) DO NOTHING
+    `);
+
+    for (const c of contacts) {
+      if (!c.phone) continue;
+      upsert.run(
+        c.phone, c.name || 'Unknown', c.category || 'unknown',
+        c.response_mode || 'auto', c.style || 'casual',
+        c.instructions || '', c.source || 'unknown',
+        c.aiva_introduced || 0,
+        c.created_at || new Date().toISOString(),
+        c.updated_at || new Date().toISOString(),
+      );
+      migrated.contacts++;
+    }
+    log(`Migrated ${migrated.contacts} contacts`);
+  } catch (e) {
+    log(`Contacts migration error: ${e.message}`);
+  }
+
+  // ── Migrate contact_context ──
+  try {
+    const contexts = v1.prepare('SELECT * FROM contact_context').all();
+    const upsert = v2.prepare(`
+      INSERT INTO contact_context (phone, relationship, last_topic, pending_items, conversation_summary, preferences, last_interaction)
+      VALUES (?, ?, ?, ?, ?, ?, ?)
+      ON CONFLICT(phone) DO NOTHING
+    `);
+
+    for (const ctx of contexts) {
+      if (!ctx.phone) continue;
+      upsert.run(
+        ctx.phone, ctx.relationship || '', ctx.last_topic || '',
+        ctx.pending_items || '[]', ctx.conversation_summary || '',
+        ctx.preferences_learned || '{}', ctx.last_interaction || null,
+      );
+      migrated.context++;
+    }
+    log(`Migrated ${migrated.context} contact contexts`);
+  } catch (e) {
+    log(`Context migration error: ${e.message}`);
+  }
+
+  // ── Migrate contact_scopes ──
+  try {
+    const scopes = v1.prepare('SELECT * FROM contact_scopes').all();
+    const upsert = v2.prepare(`
+      INSERT INTO contact_scopes (phone, scope, granted, granted_by, granted_at)
+      VALUES (?, ?, ?, ?, ?)
+      ON CONFLICT(phone, scope) DO NOTHING
+    `);
+
+    for (const s of scopes) {
+      upsert.run(s.phone, s.scope, s.granted || 0, s.granted_by || 'migrated', s.granted_at || null);
+      migrated.scopes++;
+    }
+    log(`Migrated ${migrated.scopes} scopes`);
+  } catch (e) {
+    log(`Scopes migration error: ${e.message}`);
+  }
+
+  // ── Migrate message_log ──
+  try {
+    const messages = v1.prepare('SELECT * FROM message_log ORDER BY id DESC LIMIT 5000').all();
+    const insert = v2.prepare(`
+      INSERT INTO message_log (phone, channel, direction, text, attachments, sent_by, state_at_time, created_at)
+      VALUES (?, ?, ?, ?, '[]', ?, ?, ?)
+    `);
+
+    // Check if we already have messages to avoid re-importing
+    const existingCount = v2.prepare('SELECT COUNT(*) as c FROM message_log').get().c;
+    if (existingCount === 0) {
+      for (const m of messages.reverse()) {
+        const channel = (m.source || '').includes('whatsapp') ? 'whatsapp' : 'imessage';
+        const sentBy = m.sent_by || (m.direction === 'outbound' ? 'aiva' : 'contact');
+        insert.run(
+          m.phone, channel, m.direction || 'inbound',
+          m.message_preview || '', sentBy,
+          JSON.stringify(m.rules_applied || '{}'),
+          m.timestamp || new Date().toISOString(),
+        );
+        migrated.messages++;
+      }
+      log(`Migrated ${migrated.messages} messages`);
+    } else {
+      log(`Skipping message migration - v2 already has ${existingCount} messages`);
+    }
+  } catch (e) {
+    log(`Message log migration error: ${e.message}`);
+  }
+
+  // ── Migrate settings ──
+  try {
+    const settings = v1.prepare('SELECT * FROM settings').all();
+    const upsert = v2.prepare('INSERT OR IGNORE INTO settings (key, value) VALUES (?, ?)');
+
+    for (const s of settings) {
+      // Skip v1-only settings
+      if (['scopes_migrated'].includes(s.key)) continue;
+      upsert.run(s.key, s.value);
+      migrated.settings++;
+    }
+    log(`Migrated ${migrated.settings} settings`);
+  } catch (e) {
+    log(`Settings migration error: ${e.message}`);
+  }
+
+  // ── Migrate follow_up_tracker ──
+  try {
+    const followUps = v1.prepare('SELECT * FROM follow_up_tracker').all();
+    const upsert = v2.prepare(`
+      INSERT INTO follow_up_tracker (phone, channel, contact_name, last_our_message, last_our_message_at, status, follow_up_count, max_follow_ups, next_follow_up_at, last_follow_up_at, last_follow_up_topic, opted_out, created_at, updated_at)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+      ON CONFLICT(phone) DO NOTHING
+    `);
+
+    for (const fu of followUps) {
+      upsert.run(
+        fu.phone, fu.channel || 'imessage', fu.contact_name || 'Unknown',
+        fu.last_our_message || '', fu.last_our_message_at,
+        fu.status || 'active', fu.follow_up_count || 0,
+        fu.max_follow_ups || 3, fu.next_follow_up_at,
+        fu.last_follow_up_at, fu.last_follow_up_topic || '',
+        fu.opted_out || 0, fu.created_at, fu.updated_at,
+      );
+      migrated.followUps++;
+    }
+    log(`Migrated ${migrated.followUps} follow-up trackers`);
+  } catch (e) {
+    log(`Follow-up migration error: ${e.message}`);
+  }
+
+  // ── Migrate scheduling_rules ──
+  try {
+    const rules = v1.prepare('SELECT * FROM scheduling_rules').all();
+    const upsert = v2.prepare(`
+      INSERT OR IGNORE INTO scheduling_rules (category, rule_preset, custom_instructions, structured_overrides)
+      VALUES (?, ?, ?, ?)
+    `);
+
+    for (const r of rules) {
+      upsert.run(r.category, r.rule_preset || 'flexible', r.custom_instructions || '', r.structured_overrides || '{}');
+      migrated.schedulingRules++;
+    }
+    log(`Migrated ${migrated.schedulingRules} scheduling rules`);
+  } catch (e) {
+    log(`Scheduling rules migration error: ${e.message}`);
+  }
+
+  v1.close();
+
+  log('Migration complete!');
+  log(`Summary: ${JSON.stringify(migrated)}`);
+}
+
+// Run if called directly
+if (require.main === module) {
+  run();
+}
+
+module.exports = { run };

package/router-v2/scripts/seed-faq.js

@@ -0,0 +1,67 @@
+#!/usr/bin/env node
+// ── Seed Initial FAQ Entries ─────────────────────────────
+'use strict';
+
+function run() {
+  const { initDatabase } = require('../db');
+  const { createFaq } = require('../knowledge-base');
+
+  initDatabase();
+
+  const entries = [
+    {
+      question: 'What services does Conversion Marketing Pros offer?',
+      answer: 'We offer website design and development, paid advertising management (Google Ads, Meta Ads, LinkedIn), SEO, and marketing strategy consulting.',
+      category: 'services',
+      keywords: 'services, offer, do, help, work',
+    },
+    {
+      question: 'What are your business hours?',
+      answer: 'Our team is available Monday through Friday, 9 AM to 5 PM Pacific Time. We also respond to messages on Saturdays.',
+      category: 'hours',
+      keywords: 'hours, open, available, time, when',
+    },
+    {
+      question: 'How much does a website cost?',
+      answer: 'Website projects vary based on scope and complexity. We\'d love to understand your needs first - can we hop on a quick call to discuss?',
+      category: 'pricing',
+      keywords: 'cost, price, pricing, expensive, budget, website',
+    },
+    {
+      question: 'How long does a website take to build?',
+      answer: 'A typical website redesign takes 6-8 weeks from kickoff to launch. We can expedite for an additional fee if you have a tight deadline.',
+      category: 'general',
+      keywords: 'timeline, how long, weeks, time, build, launch',
+    },
+    {
+      question: 'Where are you located?',
+      answer: 'We\'re based in Spokane, Washington, but we work with clients across the US.',
+      category: 'general',
+      keywords: 'location, where, based, office, city',
+    },
+    {
+      question: 'Do you offer free consultations?',
+      answer: 'Yes! We offer a free 30-minute discovery call to learn about your goals and see if we\'re a good fit.',
+      category: 'general',
+      keywords: 'free, consultation, discovery, call, meeting',
+    },
+  ];
+
+  let created = 0;
+  for (const entry of entries) {
+    try {
+      createFaq(entry);
+      created++;
+    } catch (e) {
+      console.log(`Skipped: ${entry.question.substring(0, 50)} - ${e.message}`);
+    }
+  }
+
+  console.log(`[SEED-FAQ] Created ${created} FAQ entries`);
+}
+
+if (require.main === module) {
+  run();
+}
+
+module.exports = { run };

package/router-v2/seed-knowledge-base.js

@@ -0,0 +1,39 @@
+#!/usr/bin/env node
+'use strict';
+
+/**
+ * Seed the FAQ entries from knowledge-base.json into the SQLite database.
+ * Usage: node seed-knowledge-base.js [--clear]
+ *   --clear: Remove all existing FAQ entries before seeding
+ */
+
+const path = require('path');
+const { listFaq, createFaq, deleteFaq } = require('./knowledge-base');
+const kbPath = path.join(__dirname, 'data', 'knowledge-base.json');
+
+// Force DB init
+const { initDatabase } = require('./db');
+initDatabase();
+
+const entries = require(kbPath);
+const doClear = process.argv.includes('--clear');
+
+if (doClear) {
+  const existing = listFaq();
+  console.log(`Clearing ${existing.length} existing FAQ entries...`);
+  for (const e of existing) deleteFaq(e.id);
+}
+
+let created = 0;
+for (const entry of entries) {
+  createFaq({
+    device_id: null,
+    question: entry.question,
+    answer: entry.answer,
+    category: entry.category,
+    keywords: entry.keywords || '',
+  });
+  created++;
+}
+
+console.log(`Seeded ${created} FAQ entries from knowledge-base.json`);