spine-framework-cortex 0.2.20 → 0.2.22

package/functions/custom_case_analysis.ts

@@ -0,0 +1,292 @@
+import { createHandler } from './_shared/middleware'
+import { adminDb } from './_shared/db'
+import { resolveTypeId, resolveAgentId, resolvePromptConfigId, resolveLinkTypeId } from './_shared/resolve-ids'
+import { runAgent } from './_shared/index'
+import { create } from './admin-data'
+import { embedResolvedCase } from './custom_kb-embeddings'
+
+/**
+ * @module custom_case_analysis
+ * @layer custom/cortex
+ * @stability custom
+ *
+ * Post-resolution case analysis. Triggered when a support ticket is resolved.
+ *
+ * Action: POST ?action=analyze_ticket
+ *
+ * Process:
+ *   1. Load ticket + all thread messages (external + internal + solution AI)
+ *   2. Create a temporary internal analysis thread wired to Case Resolution Analysis Agent
+ *   3. Call runAgent() with the full case context — agent returns structured JSON
+ *   4. Parse JSON from agent message content
+ *   5. Upsert tags, create case_analysis item, update ticket with ca_ fields
+ *   6. Trigger embedResolvedCase() to embed for future RAG
+ *
+ * The analysis thread persists as an audit trail of the AI's reasoning.
+ */
+
+// ─── TYPES ────────────────────────────────────────────────────────────────────
+
+interface AnalysisRequest { ticket_id: string }
+
+// ─── HELPERS ──────────────────────────────────────────────────────────────────
+
+async function loadConversationContext(ticketId: string): Promise<{
+  externalMessages: any[]
+  internalMessages: any[]
+  solutionMessages: any[]
+}> {
+  const { data: threads } = await adminDb
+    .from('threads')
+    .select('id, visibility, data')
+    .eq('target_type', 'items')
+    .eq('target_id', ticketId)
+
+  const result = { externalMessages: [], internalMessages: [], solutionMessages: [] } as any
+
+  for (const thread of threads || []) {
+    const { data: msgs } = await adminDb
+      .from('messages')
+      .select('content, direction, visibility, created_at')
+      .eq('thread_id', thread.id)
+      .eq('visibility', thread.data?.thread_purpose === 'solution_ai' ? 'internal' : 'public')
+      .order('created_at', { ascending: true })
+      .limit(100)
+
+    const messages = msgs || []
+    if (thread.data?.thread_purpose === 'solution_ai') {
+      result.solutionMessages = messages
+    } else if (thread.visibility === 'internal') {
+      result.internalMessages = messages
+    } else {
+      result.externalMessages = messages
+    }
+  }
+  return result
+}
+
+function formatMessages(msgs: any[], label: string): string {
+  if (!msgs.length) return ''
+  return `\n\n## ${label}\n` + msgs.map(m => {
+    const role = m.direction === 'inbound' ? 'Customer' : 'Agent'
+    return `${role}: ${m.content}`
+  }).join('\n')
+}
+
+async function upsertTag(tagData: any, accountId: string, tagTypeId: string): Promise<string | null> {
+  const { slug, name, purpose, category, applicable_to } = tagData
+  if (!slug || !name) return null
+
+  const { data: existing } = await adminDb
+    .from('items')
+    .select('id')
+    .eq('type_id', tagTypeId)
+    .eq('data->>slug', slug)
+    .maybeSingle()
+
+  if (existing) return existing.id
+
+  const { data: newTag } = await adminDb
+    .from('items')
+    .insert({
+      type_id: tagTypeId,
+      account_id: accountId,
+      title: name,
+      description: purpose || '',
+      status: 'active',
+      data: { slug, name, purpose, applicable_to: applicable_to || ['ticket'], category, usage_count: 1 }
+    })
+    .select('id')
+    .single()
+
+  return newTag?.id ?? null
+}
+
+// ─── ACTION: ANALYZE TICKET ───────────────────────────────────────────────────
+
+async function handleAnalyzeTicket(ctx: any, body: AnalysisRequest) {
+  const { ticket_id } = body
+  const account_id = ctx.accountId as string
+  if (!ticket_id) throw new Error('ticket_id is required')
+  if (!account_id) throw new Error('Account context required')
+
+  // Load ticket
+  const { data: ticket, error: ticketErr } = await adminDb
+    .from('items')
+    .select('*')
+    .eq('id', ticket_id)
+    .single()
+  if (ticketErr || !ticket) throw new Error(`Ticket not found: ${ticket_id}`)
+  if (ticket.status !== 'resolved') throw new Error('Ticket must be resolved before analysis')
+
+  // Resolve IDs
+  const [threadTypeId, analysisAgentId, promptConfigId, caseAnalysisTypeId, tagTypeId] = await Promise.all([
+    resolveTypeId('thread', 'thread'),
+    resolveAgentId('Case Resolution Analysis Agent'),
+    resolvePromptConfigId('case_analysis_prompt'),
+    resolveTypeId('item', 'case_analysis'),
+    resolveTypeId('item', 'tag'),
+  ])
+
+  // Load full conversation context (external + internal + solution AI)
+  const { externalMessages, internalMessages, solutionMessages } = await loadConversationContext(ticket_id)
+
+  // Build the analysis prompt as the user message to the agent.
+  // The agent's context_template handles placeholders; we pass everything here.
+  const conversationText =
+    formatMessages(externalMessages, 'Customer Conversation') +
+    formatMessages(internalMessages, 'Internal Support Notes') +
+    formatMessages(solutionMessages, 'Solution AI Collaboration')
+
+  const analysisPrompt = [
+    `Ticket: ${ticket.title}`,
+    `Description: ${ticket.description || ''}`,
+    `Created: ${ticket.created_at}`,
+    `Resolved: ${ticket.updated_at}`,
+    `Status: ${ticket.status}`,
+    `Priority: ${ticket.data?.priority || 'medium'}`,
+    conversationText,
+    '\nProduce the full structured postmortem JSON.'
+  ].join('\n')
+
+  // Create a dedicated analysis thread — persists as audit trail
+  const analysisThread = await create(ctx, {
+    entity: 'threads',
+    type_id: threadTypeId,
+    target_type: 'items',
+    target_id: ticket_id,
+    visibility: 'internal',
+    status: 'active',
+    data: {
+      thread_purpose: 'case_analysis',
+      agent_id: analysisAgentId,
+      prompt_config_id: promptConfigId,
+    }
+  })
+  if (!analysisThread?.id) throw new Error('Failed to create analysis thread')
+
+  // Run the agent — saves messages, handles RAG (none needed here), returns message row
+  const agentMsg = await runAgent(analysisThread.id, analysisPrompt, ctx)
+
+  // Parse structured JSON from agent response
+  let envelope: any = {}
+  try {
+    const raw = agentMsg?.content || '{}'
+    // Strip code fences if the model wrapped it
+    const cleaned = raw.replace(/^```(?:json)?\s*/i, '').replace(/\s*```$/, '').trim()
+    envelope = JSON.parse(cleaned)
+  } catch {
+    console.error('Case analysis: failed to parse agent JSON response')
+    envelope = {
+      reported_issue: ticket.description || '',
+      true_problem: 'Analysis parse failure — see raw agent message',
+      diagnostic_steps: [],
+      solution_steps: [],
+      final_solution: '',
+      confidence_score: 0.1,
+      kb_candidate: false,
+      suggested_tags: [],
+      analysis_summary: 'Structured analysis unavailable — agent response was not valid JSON.'
+    }
+  }
+
+  // Upsert tags
+  const tagIds: string[] = []
+  for (const tagData of envelope.suggested_tags || []) {
+    try {
+      const tagId = await upsertTag(tagData, account_id, tagTypeId)
+      if (tagId) tagIds.push(tagId)
+    } catch (err) {
+      console.error('Tag upsert failed:', tagData.slug, err)
+    }
+  }
+
+  // Create case_analysis item
+  const { data: caseAnalysis } = await adminDb
+    .from('items')
+    .insert({
+      type_id: caseAnalysisTypeId,
+      account_id,
+      title: `Analysis: ${ticket.title}`,
+      status: 'completed',
+      data: {
+        ticket_id,
+        analysis_data: envelope,
+        confidence_score: envelope.confidence_score || 0.5,
+        analysis_timestamp: new Date().toISOString(),
+        ai_agent_id: analysisAgentId,
+        analysis_thread_id: analysisThread.id,
+      }
+    })
+    .select('id')
+    .single()
+
+  // Link case_analysis → ticket
+  if (caseAnalysis?.id) {
+    const analyzedByLinkTypeId = await resolveLinkTypeId('analyzed_by').catch(() => null)
+    if (analyzedByLinkTypeId) {
+      const linkTypeItemId = await resolveTypeId('item', 'link').catch(() => null)
+      if (linkTypeItemId) {
+        await adminDb.from('links').upsert({
+          type_id: linkTypeItemId,
+          link_type_id: analyzedByLinkTypeId,
+          account_id,
+          source_type: 'items',
+          source_id: caseAnalysis.id,
+          target_type: 'items',
+          target_id: ticket_id,
+          link_type: 'analyzed_by',
+          created_at: new Date().toISOString(),
+          updated_at: new Date().toISOString(),
+        }, { onConflict: 'source_id,target_id,link_type_id' })
+      }
+    }
+  }
+
+  // Update ticket with ca_ fields
+  const { data: currentTicket } = await adminDb.from('items').select('data').eq('id', ticket_id).single()
+  await adminDb.from('items').update({
+    data: {
+      ...(currentTicket?.data || {}),
+      ca_reported_issue: envelope.reported_issue,
+      ca_true_problem: envelope.true_problem,
+      ca_final_solution: envelope.final_solution,
+      ca_diagnostic_steps: envelope.diagnostic_steps,
+      ca_solution_steps: envelope.solution_steps,
+      ca_analysis_tags: tagIds,
+      ca_time_to_resolution: envelope.time_to_resolution,
+      ca_back_and_forth_count: envelope.back_and_forth_count,
+      ca_escalation_required: envelope.escalation_required,
+      ca_automation_potential: envelope.automation_potential,
+      ca_customer_temperature: envelope.customer_temperature,
+      ca_kb_candidate: envelope.kb_candidate,
+      ca_sentiment_progression: envelope.sentiment_progression,
+      analysis_timestamp: new Date().toISOString(),
+    },
+    updated_at: new Date().toISOString(),
+  }).eq('id', ticket_id)
+
+  // Embed the resolved case for future triage RAG (best-effort, non-blocking)
+  embedResolvedCase(ticket_id, account_id).catch(err =>
+    console.error('embedResolvedCase failed (non-fatal):', err)
+  )
+
+  return {
+    ticketId: ticket_id,
+    caseAnalysisId: caseAnalysis?.id,
+    analysisThreadId: analysisThread.id,
+    confidence: envelope.confidence_score || 0.5,
+    kbCandidate: envelope.kb_candidate,
+    createdTags: tagIds.length,
+  }
+}
+
+// ─── HANDLER ──────────────────────────────────────────────────────────────────
+
+export const handler = createHandler(async (ctx, body) => {
+  const action = (ctx as any).query?.action
+  switch (action) {
+    case 'analyze_ticket': return handleAnalyzeTicket(ctx, body as AnalysisRequest)
+    default: throw new Error(`Unknown action: ${action}. Use 'analyze_ticket'.`)
+  }
+})

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')
+})