spine-framework-cortex 0.1.1

package/components/CortexSidebar.tsx

@@ -0,0 +1,130 @@
+/**
+ * @module src/components/cortex/CortexSidebar
+ * @audience installer
+ * @layer frontend-component
+ * @stability stable
+ *
+ * Sidebar for the Cortex internal operations application.
+ */
+
+import * as React from "react"
+import { useNavigate, useLocation } from "react-router-dom"
+import { useAuth } from "@core/contexts/AuthContext"
+import {
+  LayoutDashboard,
+  Building2,
+  Headphones,
+  Users,
+  BookOpen,
+  GraduationCap,
+  Handshake,
+  Activity,
+  Heart,
+} from "lucide-react"
+import {
+  Sidebar,
+  SidebarContent,
+  SidebarFooter,
+  SidebarGroup,
+  SidebarGroupContent,
+  SidebarGroupLabel,
+  SidebarHeader,
+  SidebarMenu,
+  SidebarMenuButton,
+  SidebarMenuItem,
+  SidebarRail,
+} from "@core/components/ui/sidebar"
+
+const crmItems = [
+  { title: "Dashboard", url: "/cortex/dashboard", icon: LayoutDashboard },
+  { title: "Accounts", url: "/cortex/crm/accounts", icon: Building2 },
+  { title: "Contacts", url: "/cortex/crm/contacts", icon: Users },
+  { title: "Deals", url: "/cortex/crm/deals", icon: Handshake },
+  { title: "Health", url: "/cortex/crm/health", icon: Heart },
+  { title: "Activity", url: "/cortex/crm/activity", icon: Activity },
+]
+
+const opsItems = [
+  { title: "Support", url: "/cortex/support", icon: Headphones },
+  { title: "Community", url: "/cortex/community", icon: Users },
+  { title: "Knowledge Base", url: "/cortex/kb", icon: BookOpen },
+  { title: "Courses", url: "/cortex/courses", icon: GraduationCap },
+]
+
+export function CortexSidebar({ ...props }: React.ComponentProps<typeof Sidebar>) {
+  const navigate = useNavigate()
+  const location = useLocation()
+  const { user } = useAuth()
+
+  const isActive = (url: string) => location.pathname.startsWith(url)
+
+  return (
+    <Sidebar {...props}>
+      <SidebarHeader>
+        <SidebarMenu>
+          <SidebarMenuItem>
+            <SidebarMenuButton size="lg" onClick={() => navigate("/cortex/dashboard")}>
+              <div className="flex aspect-square size-8 items-center justify-center rounded-lg bg-primary text-primary-foreground">
+                <span className="text-sm font-bold">Cx</span>
+              </div>
+              <div className="flex flex-col gap-0.5 leading-none">
+                <span className="font-semibold">Cortex</span>
+                <span className="text-xs text-muted-foreground">Operations</span>
+              </div>
+            </SidebarMenuButton>
+          </SidebarMenuItem>
+        </SidebarMenu>
+      </SidebarHeader>
+
+      <SidebarContent>
+        <SidebarGroup>
+          <SidebarGroupLabel>CRM</SidebarGroupLabel>
+          <SidebarGroupContent>
+            <SidebarMenu>
+              {crmItems.map((item) => (
+                <SidebarMenuItem key={item.title}>
+                  <SidebarMenuButton
+                    asChild
+                    isActive={isActive(item.url)}
+                  >
+                    <a href={item.url}>
+                      <item.icon className="h-4 w-4" />
+                      <span>{item.title}</span>
+                    </a>
+                  </SidebarMenuButton>
+                </SidebarMenuItem>
+              ))}
+            </SidebarMenu>
+          </SidebarGroupContent>
+        </SidebarGroup>
+
+        <SidebarGroup>
+          <SidebarGroupLabel>Operations</SidebarGroupLabel>
+          <SidebarGroupContent>
+            <SidebarMenu>
+              {opsItems.map((item) => (
+                <SidebarMenuItem key={item.title}>
+                  <SidebarMenuButton
+                    asChild
+                    isActive={isActive(item.url)}
+                  >
+                    <a href={item.url}>
+                      <item.icon className="h-4 w-4" />
+                      <span>{item.title}</span>
+                    </a>
+                  </SidebarMenuButton>
+                </SidebarMenuItem>
+              ))}
+            </SidebarMenu>
+          </SidebarGroupContent>
+        </SidebarGroup>
+      </SidebarContent>
+
+      <SidebarFooter className="p-4">
+        <div className="text-xs text-muted-foreground truncate">{user?.email || ''}</div>
+      </SidebarFooter>
+
+      <SidebarRail />
+    </Sidebar>
+  )
+}

package/functions/custom_anonymous-sessions.ts

@@ -0,0 +1,356 @@
+// Anonymous Session Functions
+// Uses ONLY Spine APIs (ctx.db) - NO direct database access
+// Handles stitch operation: anonymous session → identified account
+
+import { createHandler } from './_shared/middleware'
+import { calculateRecency, calculateRawScore } from './custom_funnel-scoring'
+import { resolveTypeIds, resolveLinkTypeIds } from './_shared/resolve-ids'
+
+async function resolveIds() {
+  const [types, linkTypes] = await Promise.all([
+    resolveTypeIds([
+      { kind: 'item', slug: 'anonymous_session' },
+      { kind: 'item', slug: 'funnel_signal' },
+      { kind: 'item', slug: 'opportunity_queue' },
+    ]),
+    resolveLinkTypeIds(['account_signals', 'account_opportunities']),
+  ])
+  return {
+    TYPE_IDS: {
+      anonymous_session: types['item/anonymous_session'],
+      funnel_signal: types['item/funnel_signal'],
+      opportunity_queue: types['item/opportunity_queue'],
+    },
+    LINK_TYPE_IDS: {
+      account_signals: linkTypes['account_signals'],
+      account_opportunities: linkTypes['account_opportunities'],
+    },
+  }
+}
+
+// ============================================
+// STITCH: Anonymous Session → Identified Account
+// ============================================
+
+export const stitchAnonymousToAccount = createHandler(async (ctx, body) => {
+  const { anonymous_id, person_id, account_id } = body
+
+  if (!anonymous_id || !person_id || !account_id) {
+    return { status: 'error', error: 'Missing required fields: anonymous_id, person_id, account_id' }
+  }
+
+  const now = new Date().toISOString()
+  const ids = await resolveIds()
+
+  try {
+    // 1. Get anonymous session using ctx.db
+    const { data: session, error: sessionError } = await ctx.db
+      .from('items')
+      .select('id, data')
+      .eq('type_id', ids.TYPE_IDS.anonymous_session)
+      .eq('data->identity->>anonymous_id', anonymous_id)
+      .eq('is_active', true)
+      .order('created_at', { ascending: false })
+      .limit(1)
+      .single()
+
+    if (sessionError || !session) {
+      return { status: 'error', error: 'Anonymous session not found' }
+    }
+
+    const sessionData = session.data || {}
+
+    // Check if already stitched
+    if (sessionData.lifecycle?.stitched_at) {
+      return { status: 'error', error: 'Session already stitched' }
+    }
+
+    // 2. Get account using ctx.db
+    const { data: account, error: accountError } = await ctx.db
+      .from('accounts')
+      .select('id, data')
+      .eq('id', account_id)
+      .single()
+
+    if (accountError || !account) {
+      return { status: 'error', error: 'Account not found' }
+    }
+
+    // 3. Update all signals with account_id and person_id using ctx.db
+    const { error: signalsError } = await ctx.db
+      .from('items')
+      .update({
+        account_id: account_id,
+        'data->identity->>person_id': person_id,
+        'data->processing->>stitched_at': now,
+        'data->processing->>stitched_to_account_id': account_id,
+        updated_at: now
+      })
+      .eq('type_id', ids.TYPE_IDS.funnel_signal)
+      .eq('data->identity->>anonymous_id', anonymous_id)
+      .is('account_id', null)
+
+    if (signalsError) {
+      console.error(`[Stitch] Failed to update signals: ${signalsError.message}`)
+    }
+
+    // 4. Get updated signals for recalculation
+    const { data: updatedSignals } = await ctx.db
+      .from('items')
+      .select('data')
+      .eq('type_id', ids.TYPE_IDS.funnel_signal)
+      .eq('account_id', account_id)
+      .eq('data->classification->>stage', 'identified')
+      .eq('is_active', true)
+
+    // 5. Recalculate identified rating with newly-stitched signals
+    let identifiedRating = { rating: 0, raw_score: 0, calculated_at: now, best_signal_id: null as string | null }
+
+    if (updatedSignals && updatedSignals.length > 0) {
+      let bestSignal = updatedSignals[0]
+      let bestScore = bestSignal.data?.scoring_components?.raw_score?.calculated || 0
+
+      for (const signal of updatedSignals) {
+        const score = signal.data?.scoring_components?.raw_score?.calculated || 0
+        if (score > bestScore) {
+          bestScore = score
+          bestSignal = signal
+        }
+      }
+
+      // Recalculate with current recency
+      const signalDate = new Date(bestSignal.data?.processing?.scored_at || now)
+      const recency = calculateRecency(signalDate, new Date(), 'identified')
+
+      if (recency.divisor) {
+        const newScore = calculateRawScore(
+          bestSignal.data?.action?.action_value || 1,
+          bestSignal.data?.scoring_components?.engagement?.type || 1,
+          recency.divisor
+        )
+
+        identifiedRating = {
+          rating: newScore.rating,
+          raw_score: newScore.calculated,
+          calculated_at: now,
+          best_signal_id: bestSignal.data?.id || null
+        }
+      }
+    }
+
+    // 6. Update account with stitched data using ctx.db
+    const currentFunnel = account.data?.funnel || {}
+    const anonymousRating = sessionData.scoring?.ratings?.anonymous
+
+    const updatedFunnel = {
+      ...currentFunnel,
+      current_stage: 'identified',
+      ratings: {
+        ...currentFunnel.ratings,
+        anonymous: anonymousRating ? {
+          ...anonymousRating,
+          stitched_at: now,
+          archived: true
+        } : currentFunnel.ratings?.anonymous,
+        identified: identifiedRating
+      },
+      attribution: {
+        ...currentFunnel.attribution,
+        anonymous_first_touch: sessionData.attribution?.first_touch
+      },
+      stage_history: [
+        ...(currentFunnel.stage_history || []),
+        { from: 'anonymous', to: 'identified', at: now }
+      ]
+    }
+
+    await ctx.db
+      .from('accounts')
+      .update({
+        data: { ...account.data, funnel: updatedFunnel }
+      })
+      .eq('id', account_id)
+
+    // 7. Mark session as stitched using ctx.db
+    const updatedSessionData = {
+      ...sessionData,
+      lifecycle: {
+        ...sessionData.lifecycle,
+        stitched_at: now,
+        stitched_to_account_id: account_id,
+        stitched_to_person_id: person_id
+      }
+    }
+
+    await ctx.db
+      .from('items')
+      .update({
+        data: updatedSessionData,
+        updated_at: now
+      })
+      .eq('id', session.id)
+
+    // 8. Check for immediate queue entry (strong anonymous activity)
+    let queueEntry = null
+    if (anonymousRating?.rating >= 4) {
+      const inference = { type: 'implementation', confidence: 'high' }
+
+      const queueData = {
+        identity: {
+          account_id: account_id,
+          person_id: person_id
+        },
+        trigger: {
+          source_signal_id: anonymousRating.best_signal_id,
+          trigger_stage: 'anonymous',
+          trigger_rating: anonymousRating.rating,
+          trigger_raw_score: anonymousRating.raw_score,
+          trigger_reason: 'High engagement during anonymous phase'
+        },
+        recommendation: {
+          opportunity_type: inference.type,
+          confidence: inference.confidence,
+          suggested_priority: anonymousRating.rating
+        },
+        review: {
+          status: 'pending',
+          reviewed_by: null,
+          reviewed_at: null,
+          conversion_opportunity_id: null
+        },
+        notes: {
+          reviewer_notes: null,
+          auto_reason: 'Stitched from anonymous session with high engagement'
+        }
+      }
+
+      const { data: queueItem } = await ctx.db
+        .from('items')
+        .insert({
+          type_id: ids.TYPE_IDS.opportunity_queue,
+          title: `${inference.type} - Stitched Session`,
+          account_id: account_id,
+          data: queueData
+        })
+        .select('id')
+        .single()
+
+      if (queueItem) {
+        queueEntry = { id: queueItem.id }
+
+        // Create link to account
+        await ctx.db
+          .from('links')
+          .insert({
+            link_type_id: ids.LINK_TYPE_IDS.account_opportunities,
+            source_type: 'account',
+            source_id: account_id,
+            target_type: 'item',
+            target_id: queueItem.id
+          })
+
+        // Update account queue reference
+        await ctx.db
+          .from('accounts')
+          .update({
+            data: {
+              ...account.data,
+              funnel: {
+                ...updatedFunnel,
+                queue: { pending_queue_entry_id: queueItem.id }
+              }
+            }
+          })
+          .eq('id', account_id)
+      }
+    }
+
+    // 9. Create links between account and all stitched signals
+    const { data: stitchedSignals } = await ctx.db
+      .from('items')
+      .select('id')
+      .eq('type_id', ids.TYPE_IDS.funnel_signal)
+      .eq('account_id', account_id)
+      .eq('data->processing->>stitched_at', now)
+
+    for (const signal of stitchedSignals || []) {
+      await ctx.db
+        .from('links')
+        .insert({
+          link_type_id: ids.LINK_TYPE_IDS.account_signals,
+          source_type: 'account',
+          source_id: account_id,
+          target_type: 'item',
+          target_id: signal.id,
+          data: { created_at: now, stitched: true }
+        })
+    }
+
+    return {
+      status: 'success',
+      session_id: session.id,
+      account_id,
+      person_id,
+      stitched_signals: stitchedSignals?.length || 0,
+      queue_entry: queueEntry,
+      anonymous_rating: anonymousRating?.rating || 0,
+      identified_rating: identifiedRating.rating
+    }
+
+  } catch (err) {
+    console.error('[Stitch] Error:', err)
+    return { status: 'error', error: err instanceof Error ? err.message : 'Unknown error' }
+  }
+})
+
+// ============================================
+// GET ANONYMOUS SESSION DETAILS
+// ============================================
+
+export const getAnonymousSession = createHandler(async (ctx, body) => {
+  const { anonymous_id } = body
+
+  if (!anonymous_id) {
+    return { status: 'error', error: 'Missing anonymous_id' }
+  }
+
+  const ids = await resolveIds()
+
+  // Get session using ctx.db
+  const { data: session, error } = await ctx.db
+    .from('items')
+    .select('id, data, created_at, updated_at')
+    .eq('type_id', ids.TYPE_IDS.anonymous_session)
+    .eq('data->identity->>anonymous_id', anonymous_id)
+    .eq('is_active', true)
+    .order('created_at', { ascending: false })
+    .limit(1)
+    .single()
+
+  if (error || !session) {
+    return { status: 'error', error: 'Session not found' }
+  }
+
+  // Get associated signals using ctx.db
+  const { data: signals } = await ctx.db
+    .from('items')
+    .select('id, data, created_at')
+    .eq('type_id', ids.TYPE_IDS.funnel_signal)
+    .eq('data->identity->>anonymous_id', anonymous_id)
+    .eq('is_active', true)
+    .order('created_at', { ascending: false })
+
+  return {
+    status: 'success',
+    session: {
+      id: session.id,
+      anonymous_id,
+      attribution: session.data?.attribution,
+      scoring: session.data?.scoring,
+      lifecycle: session.data?.lifecycle,
+      created_at: session.created_at,
+      updated_at: session.updated_at
+    },
+    signals: signals || []
+  }
+})