@fayz-ai/plugin-agenda 0.9.0 → 0.9.1

package/src/financial-bridge.ts

@@ -1,96 +0,0 @@
-// ---------------------------------------------------------------------------
-// Agenda × Financial Bridge — Cross-plugin integration types
-// Pure types only. Runtime implementation in bridges/create-financial-bridge.ts
-// ---------------------------------------------------------------------------
-
-/** Payment status for a booking's linked invoice */
-export type BookingPaymentStatus = 'none' | 'pending' | 'partial' | 'paid' | 'overdue' | 'cancelled'
-
-/** Compact payment summary for calendar enrichment */
-export interface BookingPaymentSummary {
-  invoiceId: string
-  referenceNumber?: string
-  status: BookingPaymentStatus
-  totalAmount: number
-  paidAmount: number
-}
-
-/** Detailed payment info with installment breakdown */
-export interface BookingPaymentDetail extends BookingPaymentSummary {
-  movements: Array<{
-    id: string
-    amount: number
-    paidAmount: number
-    status: string
-    dueDate: string
-    installmentNumber?: number
-    paymentDate?: string
-    paymentMethodTypeName?: string
-    cardBrand?: string
-    cardInstallments?: number
-  }>
-}
-
-/**
- * Bridge interface for agenda → financial plugin integration.
- * Injected via `AgendaPluginOptions.financialBridge`.
- * Follows the same DI pattern as `EntityLookup`.
- */
-export interface AgendaFinancialBridge {
-  /** Batch-resolve payment status for multiple order IDs (for calendar enrichment) */
-  resolvePaymentStatuses(orderIds: string[]): Promise<Map<string, BookingPaymentSummary>>
-
-  /** Get detailed payment info for a single booking's order */
-  getPaymentDetail(orderId: string): Promise<BookingPaymentDetail | null>
-
-  /** Create a receivable invoice from the booking's service_order. Returns invoice ID */
-  createInvoiceFromOrder(orderId: string, options?: {
-    installments?: number
-    dueDate?: string
-    paymentMethodTypeId?: string
-  }): Promise<string>
-
-  /**
-   * Accrue the assigned professional's commission for a booking's order as a
-   * payable `financial_movements` row (direction='debit', movement_kind='commission').
-   * Commission = order.total × professional commission_rate%. Resolves the rate
-   * from the `v_staff` bridge view via the order's `assignee_id`.
-   *
-   * Idempotent per order: returns the existing commission movement id if one was
-   * already accrued. Returns null when there is no professional, no configured
-   * rate, a zero base, or Supabase is unavailable (nothing to accrue).
-   */
-  createCommissionMovement?(orderId: string, options?: {
-    dueDate?: string
-  }): Promise<string | null>
-
-  /** Record a payment against a movement (installment) */
-  payMovement(input: {
-    movementId: string
-    amount: number
-    paymentDate: string
-    paymentMethodTypeId?: string
-    paymentMethodId?: string
-    bankAccountId?: string
-    cardBrand?: string
-    cardInstallments?: number
-  }): Promise<void>
-
-  /** One-step POS checkout: create invoice + pay in full. Returns paid detail. */
-  checkout(orderId: string, input: {
-    paymentMethodTypeId: string
-    paymentMethodId?: string
-    bankAccountId?: string
-    cardBrand?: string
-    cardInstallments?: number
-  }): Promise<BookingPaymentDetail>
-
-  /** Get payment methods filtered by type */
-  getPaymentMethods?(paymentMethodTypeId: string): Promise<Array<{ id: string; name: string }>>
-
-  /** Get payment method types for the payment UI */
-  getPaymentMethodTypes(): Promise<Array<{ id: string; name: string; transactionType?: string }>>
-
-  /** Get bank accounts for payment destination */
-  getBankAccounts(): Promise<Array<{ id: string; name: string; accountType: string }>>
-}

package/src/hooks/useAgendaSettings.ts

@@ -1,17 +0,0 @@
-import { usePluginPrefs } from '@fayz-ai/saas'
-
-const DEFAULTS = {
-  startTime: '07:00',
-  endTime: '21:00',
-}
-
-export function useAgendaSettings() {
-  const prefs = usePluginPrefs('agenda', DEFAULTS)
-
-  return {
-    startTime: prefs.get('startTime'),
-    endTime: prefs.get('endTime'),
-    setStartTime: (v: string) => prefs.set('startTime', v),
-    setEndTime: (v: string) => prefs.set('endTime', v),
-  }
-}

package/src/index.ts

@@ -1,297 +0,0 @@
-import React from 'react'
-import type { PluginManifest } from '@fayz-ai/core'
-import { createSafeDataProvider, registerTranslations } from '@fayz-ai/core'
-import type { AgendaPluginOptions } from './config'
-import { resolveConfig } from './config'
-import { AgendaPage } from './AgendaPage'
-import { createSupabaseAgendaProvider } from './data/supabase'
-import { createMockAgendaProvider } from './data/mock'
-import { setAgendaTenantId } from './lib/tenant'
-import { createAgendaStore } from './store'
-import { agendaRegistries } from './registries'
-import { AgendaGeneralSettings } from './components/AgendaGeneralSettings'
-import { agendaLocales } from './locales'
-import { MIGRATION_001_PUBLIC_BOOKING } from './migrations'
-import { setScheduleBlockConfig, getScheduleBlockConfig, PluginSettingsPanel } from '@fayz-ai/saas'
-
-// ---------------------------------------------------------------------------
-// Factory
-// ---------------------------------------------------------------------------
-
-export function createAgendaPlugin(options?: AgendaPluginOptions): PluginManifest {
-  const config = resolveConfig(options)
-  registerTranslations(agendaLocales)
-  const provider = options?.dataProvider ?? createSafeDataProvider(
-    () => createSupabaseAgendaProvider({ professionalKind: config.professionalKind }),
-    () => createMockAgendaProvider(),
-  )
-  const store = createAgendaStore(provider, options?.financialBridge)
-  const registries = [...agendaRegistries, ...(options?.settingsRegistries ?? [])]
-
-  // Register schedule block config globally so ScheduleEditor can read it
-  setScheduleBlockConfig({
-    defaults: config.scheduleBlockDefaults,
-    showServices: !!config.serviceLookup,
-    showConcurrent: true,
-    showBookingWindow: true,
-    showLocations: config.modules.locationSelection,
-    locations: config.locations.map((l) => ({ id: l.id, name: l.name })),
-    // Lazy fetcher — called by ScheduleEditor when locations are needed but empty
-    fetchLocations: config.modules.locationSelection && provider.getLocations
-      ? async () => {
-          const locations = await provider.getLocations!()
-          const current = getScheduleBlockConfig()
-          if (current) setScheduleBlockConfig({ ...current, locations })
-          return locations
-        }
-      : undefined,
-  })
-
-  const PageComponent: React.FC<any> = () =>
-    React.createElement(AgendaPage, { config, provider, store })
-
-  return {
-    id: 'agenda',
-    name: config.labels.pageTitle,
-    icon: 'Calendar',
-    version: '1.0.0',
-    scope: options?.scope ?? 'universal',
-    verticalId: options?.verticalId,
-    // Booking/scheduling is business-ops (clinic, salon, services) — targets
-    // the saas/admin Panel world, not the ecommerce storefront.
-    scaffolds: ['saas'],
-    defaultEnabled: true,
-    dependencies: [],
-    declaredFeatures: [
-      { id: 'appointments', label: config.labels.pageTitle, group: config.labels.pageTitle },
-      { id: 'agenda.schedules', label: 'Schedule Management', group: config.labels.pageTitle },
-    ],
-    // Recurring monthly quota — counts appointment rows created this month.
-    // (Clients/patients are the app's CRUD entity, so their cap is declared by
-    // the app's EntityDef.limitKey, not here.)
-    declaredLimits: [
-      { key: 'bookings_month', label: 'Appointments this month', table: 'appointments', period: 'month' },
-    ],
-    queryEntities: [
-      {
-        key: 'agenda:appointments',
-        entity: {
-          name: 'Appointment',
-          namePlural: 'Appointments',
-          icon: 'Calendar',
-          permission: { feature: 'appointments', action: 'read' },
-          // Keys are the PROVIDER's output shape (camelCase) — what filters/
-          // dateField/groupBy match against, not the raw DB columns.
-          fields: [
-            { key: 'startsAt', label: 'Starts at', type: 'text' },
-            { key: 'endsAt', label: 'Ends at', type: 'text' },
-            { key: 'status', label: 'Status', type: 'text' },
-            { key: 'clientName', label: 'Client', type: 'text', searchable: true },
-            { key: 'professionalName', label: 'Professional', type: 'text', searchable: true },
-            { key: 'orderTotal', label: 'Order total', type: 'number' },
-            { key: 'totalDurationMinutes', label: 'Duration (min)', type: 'number' },
-            { key: 'createdAt', label: 'Created at', type: 'text' },
-          ],
-          data: {
-            table: 'v_appointments',
-            tenantScoped: true,
-            searchColumns: ['client_name', 'professional_name'],
-          },
-        },
-      },
-    ],
-    declaredRpcs: [
-      {
-        name: 'agent_agenda_create_appointment',
-        kind: 'write' as const,
-        description:
-          'Guarded appointment create: agent_guard (role→plan→bookings_month cap), working hours, race-safe conflict check, audited.',
-        audits: true,
-      },
-      {
-        name: 'agent_agenda_update_appointment',
-        kind: 'write' as const,
-        description:
-          'Guarded appointment reschedule/reassign/cancel: agent_guard (role→plan, no cap), working hours, race-safe conflict check that skips the appointment itself, audited.',
-        audits: true,
-      },
-    ],
-
-    navigation: [
-      {
-        section: options?.navSection ?? 'main',
-        position: options?.navPosition ?? 2,
-        label: config.labels.pageTitle,
-        route: '/agenda',
-        icon: 'Calendar',
-        permission: { feature: 'appointments', action: 'read' as const },
-      },
-    ],
-
-    routes: [
-      {
-        path: '/agenda',
-        component: PageComponent,
-        permission: { feature: 'appointments', action: 'read' as const },
-        // Matches the ref agent_agenda_create_appointment returns.
-        entityRoutes: ['schedule:appointment'],
-      },
-    ],
-
-    widgets: [],
-
-    aiTools: [
-      {
-        id: 'agenda.list-appointments',
-        name: 'listAppointments',
-        description: 'Lists upcoming appointments for a given date or date range, optionally filtered by professional.',
-        icon: 'Calendar',
-        mode: 'read' as const,
-        category: 'Scheduling',
-        parameters: {
-          type: 'object' as const,
-          properties: {
-            date: { type: 'string' as const, description: 'Date (YYYY-MM-DD) or "today", "tomorrow", "this week"' },
-            professional: { type: 'string' as const, description: 'Professional name to filter by' },
-          },
-        },
-        suggestions: [
-          { label: "What's on the agenda today?" },
-          { label: 'Show me tomorrow\'s appointments' },
-          { label: 'Who has the most bookings this week?' },
-        ],
-        permission: { feature: 'appointments', action: 'read' as const },
-      },
-      {
-        id: 'agenda.create-appointment',
-        name: 'createAppointment',
-        description:
-          'Creates a new appointment. Takes IDS, not names: resolve the client/service/professional ids first via findAnything/searchRecords, then call this with an ISO start time in the tenant timezone. The user confirms before booking.',
-        icon: 'CalendarPlus',
-        mode: 'persist' as const,
-        limitKey: 'bookings_month',
-        execution: { plane: 'server' as const, kind: 'rpc' as const, rpc: 'agent_agenda_create_appointment' },
-        category: 'Scheduling',
-        parameters: {
-          type: 'object' as const,
-          properties: {
-            client_id: { type: 'string' as const, description: 'Client id (from a search)' },
-            service_id: { type: 'string' as const, description: 'Service id (from a search)' },
-            professional_id: { type: 'string' as const, description: 'Professional id (optional — auto-assigned when omitted)' },
-            starts_at: { type: 'string' as const, description: "LOCAL date-time of the business, NO timezone suffix — e.g. '2026-07-27T10:00' for 10h. The system applies the tenant timezone." },
-            notes: { type: 'string' as const, description: 'Optional notes' },
-          },
-          required: ['client_id', 'service_id', 'starts_at'],
-        },
-        suggestions: [
-          { label: 'Book a haircut for Sarah tomorrow at 10am' },
-        ],
-        permission: { feature: 'appointments', action: 'create' as const },
-      },
-      {
-        id: 'agenda.update-appointment',
-        name: 'updateAppointment',
-        description:
-          'Changes an appointment that ALREADY EXISTS: reschedule (starts_at), reassign (professional_id), cancel or confirm (status), or annotate (notes). ' +
-          'This is the ONLY way to change an appointment — the appointments entity is a read-only view, so updateRecord cannot touch it. ' +
-          'NEVER answer a reschedule or a cancellation by creating a new appointment: that leaves the original standing and double-books the professional. ' +
-          'Takes the appointment id from a previous search. The duration is preserved automatically. The user confirms before anything changes.',
-        icon: 'CalendarClock',
-        mode: 'persist' as const,
-        execution: { plane: 'server' as const, kind: 'rpc' as const, rpc: 'agent_agenda_update_appointment' },
-        category: 'Scheduling',
-        parameters: {
-          type: 'object' as const,
-          properties: {
-            appointment_id: { type: 'string' as const, description: 'Id of the appointment to change (from a search)' },
-            starts_at: { type: 'string' as const, description: "New LOCAL date-time of the business, NO timezone suffix — e.g. '2026-07-27T16:30'. Omit to keep the current time." },
-            professional_id: { type: 'string' as const, description: 'Move to another professional (optional)' },
-            status: {
-              type: 'string' as const,
-              description: 'New status — use "cancelled" to cancel',
-              enum: ['scheduled', 'confirmed', 'in_progress', 'completed', 'cancelled', 'no_show'],
-            },
-            notes: { type: 'string' as const, description: 'Optional notes' },
-          },
-          required: ['appointment_id'],
-        },
-        suggestions: [
-          { label: 'Remarca o Gustavo para 16:30' },
-          { label: 'Cancela o atendimento das 10h' },
-        ],
-        permission: { feature: 'appointments', action: 'edit' as const },
-      },
-      {
-        id: 'agenda.check-availability',
-        name: 'checkAvailability',
-        description: 'Checks available time slots for a professional on a given date.',
-        icon: 'Clock',
-        mode: 'read' as const,
-        category: 'Scheduling',
-        parameters: {
-          type: 'object' as const,
-          properties: {
-            professional: { type: 'string' as const, description: 'Professional name' },
-            date: { type: 'string' as const, description: 'Date (YYYY-MM-DD) or "today", "tomorrow"' },
-            duration: { type: 'number' as const, description: 'Required duration in minutes' },
-          },
-          required: ['professional', 'date'],
-        },
-        suggestions: [
-          { label: 'When is Ana available tomorrow?' },
-          { label: 'Find a 90-minute slot for Carlos this week' },
-        ],
-        permission: { feature: 'appointments', action: 'read' as const },
-      },
-    ],
-
-    registries,
-
-    settings: [
-      {
-        id: 'agenda',
-        label: 'Agenda',
-        icon: 'Calendar',
-        // Standard layout: General | Integrations (Google Calendar addon) | Properties.
-        component: (() => {
-          const AgendaSettingsTab: React.FC = () => React.createElement(PluginSettingsPanel, {
-            title: 'Agenda',
-            generalSettings: React.createElement(AgendaGeneralSettings),
-            registries,
-            hostPluginId: 'agenda',
-            routeBase: '/settings/agenda',
-          })
-          AgendaSettingsTab.displayName = 'AgendaSettingsTab'
-          return AgendaSettingsTab as unknown as React.ComponentType<unknown>
-        })(),
-        order: 5,
-        permission: { feature: 'appointments', action: 'read' as const },
-      },
-    ],
-    migrations: [
-      {
-        id: 'agenda-001-public-booking',
-        version: '0.3.0',
-        sql: MIGRATION_001_PUBLIC_BOOKING,
-        description:
-          'Booking read model (v_appointments) + anon public booking surface (v_public_services, get_available_slots, create_public_booking) + order_items duration/assignee columns',
-      },
-    ],
-
-    locales: agendaLocales,
-  }
-}
-
-// Re-export types for consumers
-export type { AgendaPluginOptions } from './config'
-export type { ResolvedAgendaConfig } from './config'
-export type { AgendaDataProvider } from './data/types'
-// Seedable in-memory provider — apps pass a seed to render the calendar with
-// app-specific events instead of the built-in salon sample.
-export { createMockAgendaProvider } from './data/mock'
-export type { MockAgendaSeed, MockAgendaProviderOptions } from './data/mock'
-export type { AgendaFinancialBridge, BookingPaymentStatus, BookingPaymentSummary, BookingPaymentDetail } from './financial-bridge'
-export { createFinancialBridge, computeCommissionAmount } from './bridges/create-financial-bridge'
-
-// Google Calendar integration (official addon) — settings-only plugin + helpers
-export { createGoogleCalendarPlugin, createGoogleCalendarProvider, googleCalendarConnector, bookingToEvent, eventToBookingPatch } from './integrations/google-calendar'

package/src/integrations/google-calendar/GoogleCalendarSettings.tsx

@@ -1,136 +0,0 @@
-// Google Calendar integration — settings tab (control plane UI).
-//
-// Connect/disconnect, pick the target calendar, run a manual inbound sync, and
-// see recent runs. Outbound (booking → Google) is automatic via the DB trigger;
-// this screen is the only UI surface the integration needs.
-import React, { useEffect, useState } from 'react'
-import { Calendar, Plug, Power, RefreshCw, CheckCircle2, Loader2, History, AlertCircle } from 'lucide-react'
-import { Button, toast } from '@fayz-ai/ui'
-import { createGoogleCalendarProvider } from './data/supabase'
-import type { CalendarIntegration, CalendarSyncLogEntry } from './types'
-
-const provider = createGoogleCalendarProvider()
-
-export function GoogleCalendarSettings() {
-  const [integration, setIntegration] = useState<CalendarIntegration | null>(null)
-  const [loading, setLoading] = useState(true)
-  const [calendarId, setCalendarId] = useState('primary')
-  const [connecting, setConnecting] = useState(false)
-  const [syncing, setSyncing] = useState(false)
-  const [log, setLog] = useState<CalendarSyncLogEntry[]>([])
-
-  async function load() {
-    setLoading(true)
-    try {
-      const found = await provider.getIntegration()
-      setIntegration(found)
-      if (found) { setCalendarId(found.calendarId); void provider.getSyncLog().then(setLog) }
-    } finally { setLoading(false) }
-  }
-
-  useEffect(() => { void load() }, [])
-
-  async function handleConnect() {
-    setConnecting(true)
-    try {
-      const url = await provider.getConnectUrl()
-      window.location.href = url // → Google consent, then back to the app
-    } catch (e: any) {
-      toast.error(e?.message ?? 'Connect failed')
-      setConnecting(false)
-    }
-  }
-
-  async function handleDisconnect() {
-    await provider.disconnect()
-    toast.success('Disconnected')
-    void load()
-  }
-
-  async function handleSaveCalendar() {
-    await provider.setCalendar(calendarId)
-    toast.success('Saved')
-  }
-
-  async function handleSyncNow() {
-    setSyncing(true)
-    try {
-      const res = await provider.syncNow()
-      toast.success(`Synced — ${res.written} updated`)
-      void provider.getSyncLog().then(setLog)
-      void load()
-    } catch (e: any) {
-      toast.error(e?.message ?? 'Sync failed')
-    } finally { setSyncing(false) }
-  }
-
-  const connected = !!integration?.connected
-
-  return (
-    <div className="space-y-6 max-w-3xl">
-      <div className="flex items-center gap-2">
-        <Calendar className="h-5 w-5 text-muted-foreground" />
-        <div>
-          <h2 className="text-lg font-semibold tracking-tight">Google Calendar</h2>
-          <p className="text-sm text-muted-foreground">Two-way sync between your bookings and Google Calendar.</p>
-        </div>
-        {connected && (
-          <span className="ml-auto inline-flex items-center gap-1 text-xs text-success">
-            <CheckCircle2 className="h-3.5 w-3.5" /> Connected
-          </span>
-        )}
-      </div>
-
-      <section className="rounded-lg border bg-card shadow-sm p-5 space-y-4">
-        {loading ? (
-          <div className="py-6 text-center text-sm text-muted-foreground"><Loader2 className="h-4 w-4 animate-spin inline" /></div>
-        ) : !connected ? (
-          <div className="text-center py-6">
-            <p className="text-sm text-muted-foreground mb-3">Connect a Google account to sync bookings both ways.</p>
-            <Button onClick={handleConnect} disabled={connecting}>
-              {connecting ? <Loader2 className="h-4 w-4 animate-spin" /> : <Plug className="h-4 w-4" />} Connect Google Calendar
-            </Button>
-          </div>
-        ) : (
-          <>
-            <div className="flex flex-wrap items-end gap-3">
-              <label className="block flex-1 min-w-[200px]">
-                <span className="text-xs font-medium text-muted-foreground">Calendar ID</span>
-                <input value={calendarId} onChange={(e) => setCalendarId(e.target.value)} placeholder="primary"
-                  className="w-full mt-1 rounded-input border border-input bg-card px-3 py-2 text-sm focus:outline-none focus:ring-2 focus:ring-ring" />
-              </label>
-              <Button variant="outline" size="sm" onClick={handleSaveCalendar}>Save</Button>
-              <Button variant="outline" size="sm" onClick={handleSyncNow} disabled={syncing}>
-                <RefreshCw className={`h-3.5 w-3.5 ${syncing ? 'animate-spin' : ''}`} /> Sync now
-              </Button>
-              <Button variant="outline" size="sm" onClick={handleDisconnect}>
-                <Power className="h-3.5 w-3.5" /> Disconnect
-              </Button>
-            </div>
-            {integration?.lastSyncAt && (
-              <p className="text-[11px] text-muted-foreground">Last sync: {new Date(integration.lastSyncAt).toLocaleString()}</p>
-            )}
-          </>
-        )}
-      </section>
-
-      {log.length > 0 && (
-        <section className="rounded-lg border bg-card shadow-sm p-5 space-y-2">
-          <div className="flex items-center gap-2"><History className="h-4 w-4 text-muted-foreground" /><h3 className="text-sm font-semibold">History</h3></div>
-          <div className="rounded-md border divide-y text-sm">
-            {log.map((r) => (
-              <div key={r.id} className="flex items-center gap-3 px-3 py-2">
-                <span className="text-muted-foreground text-xs">{new Date(r.createdAt).toLocaleString()}</span>
-                <span className="text-[10px] uppercase tracking-wide px-1 py-px rounded bg-muted text-muted-foreground">{r.direction}</span>
-                <span className="ml-auto text-xs">{r.written} written / {r.fetched} fetched</span>
-                {r.status === 'success'
-                  ? <CheckCircle2 className="h-3.5 w-3.5 text-success" />
-                  : <AlertCircle className="h-3.5 w-3.5 text-warning" />}
-              </div>
-            ))}
-          </div>
-        </section>
-      )}
-    </div>
-  )
-}

package/src/integrations/google-calendar/components/CalendarColorDot.tsx

@@ -1,23 +0,0 @@
-// A small round swatch tinted with a Google calendar's backgroundColor.
-//
-// Google's calendarList entries carry a `backgroundColor` hex; we render it as a
-// dot next to the calendar summary in the de-para list and as the leading dot of
-// the origin badge in the import wizard. Falls back to the muted border when a
-// calendar has no color (rare, e.g. some shared calendars).
-import React from 'react'
-
-export function CalendarColorDot({
-  color,
-  className = '',
-}: {
-  color?: string | null
-  className?: string
-}) {
-  return (
-    <span
-      className={`inline-block h-2.5 w-2.5 shrink-0 rounded-full border border-black/10 ${className}`}
-      style={{ backgroundColor: color || 'hsl(var(--muted-foreground))' }}
-      aria-hidden
-    />
-  )
-}