spine-framework-portal 0.1.1 → 0.1.2

package/functions/custom_portal-community-escalation.ts

@@ -0,0 +1,202 @@
+// Portal Community Escalation Handler
+// Converts unanswered community posts to support tickets.
+// Standalone: no dependency on cortex functions.
+// Triggered by cron — see portal seed/triggers.json.
+
+import { createHandler } from './_shared/middleware'
+import { adminDb } from './_shared/db'
+
+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 {
+    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
+    }
+
+    const { data: newTicket, error: insertError } = await adminDb
+      .from('items')
+      .insert({
+        type_slug: 'support_ticket',
+        title: `Escalated: ${post.title}`,
+        description: post.description || 'No description provided',
+        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
+
+    await adminDb.from('threads').insert({
+      target_type: 'items',
+      target_id: ticketId,
+      visibility: 'external',
+      status: 'active',
+    })
+
+    await adminDb
+      .from('items')
+      .update({
+        data: {
+          ...post.data,
+          status: 'escalated',
+          escalation: {
+            escalated_to_ticket_id: ticketId,
+            escalated_at: new Date().toISOString(),
+            reason: 'unanswered_24h',
+          },
+        },
+        updated_at: new Date().toISOString(),
+      })
+      .eq('id', post.id)
+
+    // Attempt to trigger support triage pipeline if present
+    try {
+      const { data: pipeline } = await adminDb
+        .from('pipelines')
+        .select('id')
+        .ilike('name', '%support%triage%')
+        .limit(1)
+        .maybeSingle()
+
+      if (pipeline) {
+        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: post.account_id,
+            title: post.title,
+            description: post.description || '',
+            source: 'community_escalation',
+          },
+        })
+      }
+    } catch (err) {
+      console.error('Failed to trigger triage pipeline:', err)
+    }
+
+    console.log(`Escalated post ${post.id} to ticket ${ticketId}`)
+    return ticketId
+
+  } catch (err) {
+    console.error(`Failed to escalate post ${post.id}:`, err)
+    throw err
+  }
+}
+
+export const checkUnanswered = createHandler(async (_ctx, _body) => {
+  console.log('[PortalEscalation] Starting community escalation check...')
+
+  try {
+    const cutoffTime = new Date(Date.now() - 24 * 60 * 60 * 1000).toISOString()
+
+    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 }
+    }
+
+    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(`[PortalEscalation] Found ${postsToEscalate.length} unanswered posts`)
+
+    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)
+      }
+    }
+
+    return {
+      status: 'ok',
+      processed: postsToEscalate.length,
+      escalated: results.escalated.length,
+      failed: results.failed.length,
+      skipped: results.skipped.length,
+      details: results,
+    }
+
+  } catch (err) {
+    console.error('[PortalEscalation] Failed:', err)
+    const error: any = new Error('Failed to process community escalation')
+    error.statusCode = 500
+    throw error
+  }
+})

package/functions/custom_portal-signals.ts

@@ -1,11 +1,45 @@
+// Portal Signal Handler
+// Records portal user actions as funnel signals in the items table.
+// Portal users are always identified — no anonymous session handling.
+// Standalone: no dependency on cortex functions.
+
 import { createHandler } from './_shared/middleware'
-import { processSignal } from './custom_funnel-signal'
+import { adminDb } from './_shared/db'
+import { resolveTypeIds, resolveAccountId } from './_shared/resolve-ids'
+
+async function resolveIds() {
+  const [types, unidentifiedVisitorsAccountId] = await Promise.all([
+    resolveTypeIds([{ kind: 'item', slug: 'funnel_signal' }]),
+    resolveAccountId('unidentified-visitors'),
+  ])
+  return {
+    FUNNEL_SIGNAL_TYPE_ID: types['item/funnel_signal'],
+    UNIDENTIFIED_VISITORS_ACCOUNT_ID: unidentifiedVisitorsAccountId,
+  }
+}
+
+function ratingToTemperature(rating: number): 'cold' | 'warm' | 'hot' {
+  if (rating <= 2) return 'cold'
+  if (rating <= 3) return 'warm'
+  return 'hot'
+}
+
+function calculateSimpleScore(actionValue: number): { calculated: number; rating: 1 | 2 | 3 | 4 | 5 } {
+  const calculated = actionValue
+  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, rating }
+}
 
 export const handler = createHandler(async (ctx, body) => {
   const { action_type, action_value, action_description, session_id } = body || {}
 
-  if (!action_type || typeof action_value !== 'number') {
-    const err: any = new Error('action_type and action_value are required')
+  if (!action_type || ![1, 2, 5].includes(action_value)) {
+    const err: any = new Error('action_type and action_value (1, 2, or 5) are required')
     err.statusCode = 400
     throw err
   }
@@ -16,18 +50,92 @@ export const handler = createHandler(async (ctx, body) => {
     throw err
   }
 
-  const payload = {
-    account_id: ctx.accountId,
-    person_id: ctx.principal.id,
-    session_id: session_id || `portal_${ctx.principal.id}_${Date.now()}`,
-    stage: 'identified',
-    source: 'int',
-    action_type,
-    action_value,
-    ...(action_description && { action_description }),
+  const ids = await resolveIds()
+  const now = new Date().toISOString()
+  const scoring = calculateSimpleScore(action_value)
+  const resolvedSessionId = session_id || `portal_${ctx.principal.id}_${Date.now()}`
+
+  const signalData = {
+    identity: {
+      anonymous_id: null,
+      person_id: ctx.principal.id,
+      account_id: ctx.accountId,
+      session_id: resolvedSessionId,
+    },
+    classification: {
+      stage: 'identified',
+      source: 'int',
+    },
+    action: {
+      action_type,
+      action_value,
+      action_description: action_description || null,
+    },
+    scoring_components: {
+      raw_score: {
+        calculated: scoring.calculated,
+        max_possible: 25,
+        rating: scoring.rating,
+      },
+    },
+    processing: {
+      received_at: now,
+      enriched_at: now,
+      scored_at: now,
+      stitched_at: null,
+      stitched_to_account_id: null,
+    },
+  }
+
+  const { data, error } = await adminDb
+    .from('items')
+    .insert({
+      type_id: ids.FUNNEL_SIGNAL_TYPE_ID,
+      title: `${action_type} - ${action_value}`,
+      account_id: ctx.accountId,
+      data: signalData,
+    })
+    .select('id')
+    .single()
+
+  if (error) {
+    throw new Error(`Failed to record portal signal: ${error.message}`)
   }
 
-  await processSignal(payload, { accountId: ctx.accountId, requestId: ctx.requestId }, {})
+  // Update account funnel data
+  const { data: account } = await adminDb
+    .from('accounts')
+    .select('data')
+    .eq('id', ctx.accountId)
+    .single()
+
+  if (account) {
+    const currentRating = account.data?.ratings?.identified?.rating || 0
+    const shouldUpdate = scoring.rating > currentRating
+
+    await adminDb
+      .from('accounts')
+      .update({
+        data: {
+          ...account.data,
+          ...(shouldUpdate && {
+            lead_score: scoring.calculated,
+            temperature: ratingToTemperature(scoring.rating),
+            lifecycle_stage: 'identified',
+            ratings: {
+              ...(account.data?.ratings || {}),
+              identified: {
+                rating: scoring.rating,
+                raw_score: scoring.calculated,
+                calculated_at: now,
+              },
+            },
+          }),
+          last_signal_at: now,
+        },
+      })
+      .eq('id', ctx.accountId)
+  }
 
-  return { status: 'ok' }
+  return { status: 'ok', signal_id: data.id, rating: scoring.rating }
 })

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "spine-framework-portal",
-  "version": "0.1.1",
+  "version": "0.1.2",
   "description": "Customer Portal — self-service portal app for Spine Framework",
   "type": "module",
   "license": "MIT",
@@ -10,8 +10,7 @@
     "directory": "custom/apps/customer-portal"
   },
   "peerDependencies": {
-    "spine-framework": ">=0.1.0",
-    "spine-framework-cortex": ">=0.1.0"
+    "spine-framework": ">=0.1.0"
   },
   "files": [
     "index.tsx",

package/seed/triggers.json

@@ -5,7 +5,7 @@
     "trigger_type": "cron",
     "event_type": null,
     "config": {
-      "function": "custom_community-escalation.checkUnanswered",
+      "function": "custom_portal-community-escalation.checkUnanswered",
       "schedule": "0 */4 * * *",
       "timezone": "UTC",
       "description": "Check for community posts >24h without answers, create tickets"