spine-framework-cortex 0.1.1

package/functions/custom_community-escalation.ts

@@ -0,0 +1,234 @@
+import { createHandler } from './_shared/middleware'
+import { adminDb } from './_shared/db'
+
+/**
+ * Custom Community Escalation Handler
+ * 
+ * Triggered by cron schedule to convert unanswered community posts to support tickets.
+ * Posts unanswered for 24+ hours are escalated to the AI-first support queue.
+ * 
+ * Uses adminDb (service role) for system-level operations across all accounts.
+ */
+
+interface CommunityPost {
+  id: string
+  title: string
+  description?: string
+  account_id: string
+  person_id: string
+  created_at: string
+  data?: {
+    category?: string
+    tags?: string[]
+    status?: string
+    escalation?: {
+      escalated_to_ticket_id?: string
+    }
+  }
+}
+
+async function escalatePostToTicket(post: CommunityPost): Promise<string | null> {
+  try {
+    // Check if a ticket already exists for this post
+    const { data: existingTicket } = await adminDb
+      .from('items')
+      .select('id')
+      .eq('type_slug', 'support_ticket')
+      .eq('data->>source_post_id', post.id)
+      .limit(1)
+      .maybeSingle()
+
+    if (existingTicket) {
+      console.log(`Post ${post.id} already escalated to ticket ${existingTicket.id}`)
+      return null
+    }
+
+    // Create the support ticket
+    const ticketTitle = `Escalated: ${post.title}`
+    const ticketDescription = post.description || 'No description provided'
+
+    const { data: newTicket, error: insertError } = await adminDb
+      .from('items')
+      .insert({
+        type_slug: 'support_ticket',
+        title: ticketTitle,
+        description: ticketDescription,
+        account_id: post.account_id,
+        person_id: post.person_id,
+        status: 'open',
+        data: {
+          source_post_id: post.id,
+          source: 'community_escalation',
+          escalated_at: new Date().toISOString(),
+          original_category: post.data?.category || 'general',
+          original_tags: post.data?.tags || [],
+          community_status: 'unanswered_24h',
+          ai_metadata: {
+            confidence_threshold: 0.75,
+            escalation_reason: 'community_unanswered',
+            problem_statement: post.title,
+            source_content: post.description?.slice(0, 1000)
+          }
+        }
+      })
+      .select('id')
+      .single()
+
+    if (insertError || !newTicket) {
+      throw new Error(`Failed to create ticket: ${insertError?.message}`)
+    }
+
+    const ticketId = newTicket.id
+
+    // Create external thread for the ticket
+    await adminDb.from('threads').insert({
+      target_type: 'items',
+      target_id: ticketId,
+      visibility: 'external',
+      status: 'active'
+    })
+
+    // Update the community post to mark it as escalated
+    const updatedData = {
+      ...post.data,
+      status: 'escalated',
+      escalation: {
+        escalated_to_ticket_id: ticketId,
+        escalated_at: new Date().toISOString(),
+        reason: 'unanswered_24h'
+      }
+    }
+
+    await adminDb
+      .from('items')
+      .update({ data: updatedData, updated_at: new Date().toISOString() })
+      .eq('id', post.id)
+
+    // Trigger AI triage agent on the new ticket
+    await triggerTriageAgent(ticketId, post.account_id, post.title, post.description)
+
+    console.log(`Successfully escalated post ${post.id} to ticket ${ticketId}`)
+    return ticketId
+
+  } catch (err) {
+    console.error(`Failed to escalate post ${post.id}:`, err)
+    throw err
+  }
+}
+
+async function triggerTriageAgent(
+  ticketId: string,
+  accountId: string,
+  title: string,
+  content?: string
+): Promise<void> {
+  try {
+    // Find the support triage pipeline
+    const { data: pipeline } = await adminDb
+      .from('pipelines')
+      .select('id')
+      .ilike('name', '%support%triage%')
+      .limit(1)
+      .maybeSingle()
+
+    if (!pipeline) {
+      console.log('No support triage pipeline found, skipping auto-trigger')
+      return
+    }
+
+    // Create pipeline execution
+    await adminDb.from('pipeline_executions').insert({
+      pipeline_id: pipeline.id,
+      target_type: 'items',
+      target_id: ticketId,
+      status: 'pending',
+      input_context: {
+        ticket_id: ticketId,
+        account_id: accountId,
+        title: title,
+        description: content || '',
+        source: 'community_escalation'
+      }
+    })
+  } catch (err) {
+    console.error('Failed to trigger triage agent:', err)
+    // Non-fatal: ticket was created, triage can be run manually
+  }
+}
+
+export const handler = createHandler(async (_ctx, _body) => {
+  console.log('Starting community escalation check...')
+
+  try {
+    const cutoffTime = new Date(Date.now() - 24 * 60 * 60 * 1000).toISOString()
+
+    // Find posts unanswered for 24+ hours
+    const { data: unansweredPosts, error: postsError } = await adminDb
+      .from('items')
+      .select('id, title, description, account_id, person_id, created_at, data')
+      .eq('type_slug', 'community_post')
+      .not('data->>status', 'eq', 'escalated')
+      .lt('created_at', cutoffTime)
+      .order('created_at', { ascending: true })
+      .limit(50)
+
+    if (postsError) {
+      throw new Error(`Failed to fetch posts: ${postsError.message}`)
+    }
+
+    if (!unansweredPosts || unansweredPosts.length === 0) {
+      return { status: 'ok', processed: 0, escalated: 0, failed: 0, skipped: 0 }
+    }
+
+    // Filter out posts that have replies
+    const postsToEscalate: CommunityPost[] = []
+    for (const post of unansweredPosts) {
+      const { data: replies } = await adminDb
+        .from('items')
+        .select('id')
+        .eq('type_slug', 'community_reply')
+        .eq('data->>post_id', post.id)
+        .gt('created_at', post.created_at)
+        .limit(1)
+
+      if (!replies || replies.length === 0) {
+        postsToEscalate.push(post as CommunityPost)
+      }
+    }
+
+    console.log(`Found ${postsToEscalate.length} unanswered posts to escalate`)
+
+    const results = { escalated: [] as string[], failed: [] as string[], skipped: [] as string[] }
+
+    for (const post of postsToEscalate) {
+      try {
+        const ticketId = await escalatePostToTicket(post)
+        if (ticketId) {
+          results.escalated.push(post.id)
+        } else {
+          results.skipped.push(post.id)
+        }
+      } catch (err) {
+        console.error(`Failed to escalate post ${post.id}:`, err)
+        results.failed.push(post.id)
+      }
+    }
+
+    console.log('Escalation complete:', results)
+
+    return {
+      status: 'ok',
+      processed: postsToEscalate.length,
+      escalated: results.escalated.length,
+      failed: results.failed.length,
+      skipped: results.skipped.length,
+      details: results
+    }
+
+  } catch (err) {
+    console.error('Community escalation failed:', err)
+    const error: any = new Error('Failed to process community escalation')
+    error.statusCode = 500
+    throw error
+  }
+})

package/functions/custom_cortex-chunks.ts

@@ -0,0 +1,52 @@
+import { createHandler } from './_shared/middleware'
+import { adminDb } from './_shared/db'
+
+export const handler = createHandler(async (ctx, body) => {
+  const { action } = ctx.query || {}
+  const method = ctx.query?.method || 'GET'
+
+  switch (action) {
+    case 'list':
+      if (method === 'GET') {
+        try {
+          // Read chunks from the project root directory
+          const fs = require('fs')
+          const path = require('path')
+          const chunksPath = path.join(process.cwd(), 'chunks.json')
+          const fileContent = fs.readFileSync(chunksPath, 'utf8')
+          const data = JSON.parse(fileContent)
+          
+          return {
+            chunks: data.chunks || [],
+            total: data.chunks?.length || 0,
+            loaded_at: new Date().toISOString()
+          }
+        } catch (error) {
+          throw new Error(`Failed to load chunks: ${error instanceof Error ? error.message : 'Unknown error'}`)
+        }
+      }
+      break
+    
+    default:
+      if (method === 'GET') {
+        try {
+          // Read chunks from the project root directory
+          const fs = require('fs')
+          const path = require('path')
+          const chunksPath = path.join(process.cwd(), 'chunks.json')
+          const fileContent = fs.readFileSync(chunksPath, 'utf8')
+          const data = JSON.parse(fileContent)
+          
+          return {
+            chunks: data.chunks || [],
+            total: data.chunks?.length || 0,
+            loaded_at: new Date().toISOString()
+          }
+        } catch (error) {
+          throw new Error(`Failed to load chunks: ${error instanceof Error ? error.message : 'Unknown error'}`)
+        }
+      }
+  }
+
+  throw new Error('Invalid action or method')
+})

package/functions/custom_cortex-handler.ts

@@ -0,0 +1,35 @@
+/**
+ * Cortex Webhook Handler
+ * 
+ * Convention: custom_*.ts files are assembled into /functions/
+ * and loaded by integration-routes via: import('./custom_cortex-handler')
+ *
+ * Receives: (sanitizedData, context, event)
+ * Returns: plain text or object
+ */
+export default async function cortexHandler(
+  data: Record<string, any>,
+  ctx: {
+    integrationId: string
+    accountId: string
+    slug: string
+    principal: { id: string; type: string; accountId: string }
+    requestId: string
+    headers: Record<string, string>
+  },
+  event: {
+    httpMethod: string
+    headers: Record<string, string>
+    body: any
+    path: string
+    queryStringParameters: Record<string, string>
+  }
+): Promise<string> {
+  console.log(`[${ctx.requestId}] Cortex handler received:`, {
+    testText: data['test-text'],
+    integrationId: ctx.integrationId,
+    accountId: ctx.accountId
+  })
+
+  return data['test-text']
+}

package/functions/custom_funnel-scoring.ts

@@ -0,0 +1,256 @@
+// Funnel Scoring Engine
+// Pure calculation utilities - NO database access
+// All functions are deterministic and testable
+
+// ============================================
+// TYPES
+// ============================================
+
+export interface EngagementResult {
+  type: 1 | 2 | 5
+  context: 'first_visit' | 'deep_session' | 'return_visit'
+  session_depth: number
+  prior_session_count?: number
+}
+
+export interface RecencyResult {
+  divisor: 1 | 2 | 5 | null
+  age_days: number
+  window: 'fresh' | 'cooling' | 'stale' | 'expired'
+}
+
+export interface RawScoreResult {
+  calculated: number
+  max_possible: number
+  rating: 1 | 2 | 3 | 4 | 5
+}
+
+export interface StageConfig {
+  max_lookback_days: number
+  fresh_days: number
+  cooling_days: number
+  stale_days: number
+  deep_engagement_action_count: number
+}
+
+// Stage configurations per plan
+const STAGE_CONFIGS: Record<string, StageConfig> = {
+  anonymous: {
+    max_lookback_days: 90,
+    fresh_days: 7,
+    cooling_days: 30,
+    stale_days: 90,
+    deep_engagement_action_count: 4
+  },
+  identified: {
+    max_lookback_days: 120,
+    fresh_days: 14,
+    cooling_days: 45,
+    stale_days: 90,
+    deep_engagement_action_count: 3
+  },
+  installed: {
+    max_lookback_days: 90,
+    fresh_days: 7,
+    cooling_days: 21,
+    stale_days: 45,
+    deep_engagement_action_count: 3
+  }
+}
+
+// ============================================
+// ENGAGEMENT CALCULATION
+// ============================================
+
+export function calculateEngagement(
+  priorSignals: Array<{ session_id: string; occurred_at: string }>,
+  currentSessionId: string,
+  currentOccurredAt: string,
+  stage: string
+): EngagementResult {
+  const config = STAGE_CONFIGS[stage] || STAGE_CONFIGS.anonymous
+
+  // First visit - no prior signals
+  if (priorSignals.length === 0) {
+    return { type: 1, context: 'first_visit', session_depth: 1 }
+  }
+
+  // Check for return visit
+  const lastSignal = priorSignals[priorSignals.length - 1]
+  const hoursSinceLast = differenceInHours(
+    new Date(currentOccurredAt),
+    new Date(lastSignal.occurred_at)
+  )
+  const isNewSession = currentSessionId !== lastSignal.session_id
+
+  if (isNewSession || hoursSinceLast >= 4) {
+    const uniqueSessions = new Set(priorSignals.map(s => s.session_id)).size
+    return {
+      type: 5,
+      context: 'return_visit',
+      session_depth: 1,
+      prior_session_count: uniqueSessions
+    }
+  }
+
+  // Same session - check depth
+  const sameSessionSignals = priorSignals.filter(s =>
+    s.session_id === currentSessionId &&
+    isSameDay(new Date(s.occurred_at), new Date(currentOccurredAt))
+  )
+
+  const sessionDepth = sameSessionSignals.length + 1
+
+  if (sessionDepth >= config.deep_engagement_action_count) {
+    return { type: 2, context: 'deep_session', session_depth: sessionDepth }
+  }
+
+  return { type: 1, context: 'first_visit', session_depth: sessionDepth }
+}
+
+// ============================================
+// RECENCY CALCULATION
+// ============================================
+
+export function calculateRecency(
+  occurredAt: Date,
+  now: Date = new Date(),
+  stage: string = 'anonymous'
+): RecencyResult {
+  const config = STAGE_CONFIGS[stage] || STAGE_CONFIGS.anonymous
+  const ageDays = differenceInDays(now, occurredAt)
+
+  if (ageDays > config.max_lookback_days) {
+    return { divisor: null, age_days: ageDays, window: 'expired' }
+  }
+
+  if (ageDays <= config.fresh_days) {
+    return { divisor: 1, age_days: ageDays, window: 'fresh' }
+  }
+
+  if (ageDays <= config.cooling_days) {
+    return { divisor: 2, age_days: ageDays, window: 'cooling' }
+  }
+
+  return { divisor: 5, age_days: ageDays, window: 'stale' }
+}
+
+// ============================================
+// RAW SCORE CALCULATION
+// ============================================
+
+export function calculateRawScore(
+  actionValue: 1 | 2 | 5,
+  engagementType: 1 | 2 | 5,
+  recencyDivisor: 1 | 2 | 5
+): RawScoreResult {
+  const calculated = (actionValue * engagementType) / recencyDivisor
+
+  let rating: 1 | 2 | 3 | 4 | 5
+  if (calculated <= 1) rating = 1
+  else if (calculated <= 4) rating = 2
+  else if (calculated <= 8) rating = 3
+  else if (calculated <= 15) rating = 4
+  else rating = 5
+
+  return {
+    calculated,
+    max_possible: 25, // 5 * 5 / 1
+    rating
+  }
+}
+
+// ============================================
+// BEST-SIGNAL-WINS CALCULATION
+// ============================================
+
+export function findBestSignal<T extends { scoring_components?: { raw_score?: { calculated?: number; rating?: number } } }>(
+  signals: T[]
+): { signal: T | null; rating: number; raw_score: number } {
+  if (signals.length === 0) {
+    return { signal: null, rating: 0, raw_score: 0 }
+  }
+
+  let bestSignal = signals[0]
+  let bestScore = signals[0]?.scoring_components?.raw_score?.calculated || 0
+
+  for (const signal of signals) {
+    const score = signal?.scoring_components?.raw_score?.calculated || 0
+    if (score > bestScore) {
+      bestScore = score
+      bestSignal = signal
+    }
+  }
+
+  return {
+    signal: bestSignal,
+    rating: bestSignal?.scoring_components?.raw_score?.rating || 0,
+    raw_score: bestScore
+  }
+}
+
+// ============================================
+// UTILITY FUNCTIONS
+// ============================================
+
+function differenceInHours(date1: Date, date2: Date): number {
+  const msPerHour = 1000 * 60 * 60
+  return Math.abs(date1.getTime() - date2.getTime()) / msPerHour
+}
+
+function differenceInDays(date1: Date, date2: Date): number {
+  return Math.floor(differenceInHours(date1, date2) / 24)
+}
+
+function isSameDay(date1: Date, date2: Date): boolean {
+  return date1.toDateString() === date2.toDateString()
+}
+
+// ============================================
+// REFERRER CATEGORIZATION
+// ============================================
+
+export function categorizeReferrer(referrerDomain: string): string {
+  const social = ['linkedin.com', 'twitter.com', 'x.com', 'facebook.com', 'instagram.com']
+  const search = ['google.com', 'bing.com', 'duckduckgo.com']
+
+  const domain = referrerDomain.toLowerCase()
+
+  if (social.some(s => domain.includes(s))) return 'social'
+  if (search.some(s => domain.includes(s))) return 'search'
+  if (!domain || domain === 'direct') return 'direct'
+
+  return 'referral'
+}
+
+// ============================================
+// OPPORTUNITY TYPE INFERENCE
+// ============================================
+
+export function inferOpportunityType(
+  signals: Array<{ action?: { action_type: string } }>,
+  stage: string,
+  rating: number
+): { type: string; confidence: 'low' | 'medium' | 'high' } {
+  const actionTypes = signals.map(s => s.action?.action_type || '').join(' ')
+
+  // High-value signals indicate specific opportunities
+  if (actionTypes.includes('pricing') && rating >= 4) {
+    return { type: 'advanced_portal', confidence: 'high' }
+  }
+  if (actionTypes.includes('health_ping') && actionTypes.includes('production')) {
+    return { type: 'managed_services', confidence: 'high' }
+  }
+  if (actionTypes.includes('support_ticket') && rating >= 3) {
+    return { type: 'support_plan', confidence: 'medium' }
+  }
+  if (stage === 'installed' && rating >= 4) {
+    return { type: 'expansion', confidence: 'medium' }
+  }
+
+  // Default based on stage
+  if (stage === 'anonymous') return { type: 'implementation', confidence: 'low' }
+  if (stage === 'identified') return { type: 'advanced_portal', confidence: 'low' }
+
+  return { type: 'advocate', confidence: 'low' }
+}