spine-framework-cortex 0.1.19 → 0.2.0

package/functions/custom_community-escalation.ts

@@ -1,234 +0,0 @@
-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

@@ -1,52 +0,0 @@
-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_funnel-scoring.ts

@@ -1,256 +0,0 @@
-// 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' }
-}