spine-framework-cortex 0.2.21 → 0.2.22

package/functions/custom_kb-embeddings.ts

@@ -4,7 +4,7 @@ import { chunkArticle, htmlToPlainText } from './custom_kb-chunker'
 
 interface KBEmbeddingRequest {
   item_id: string
-  vector_types: ('semantic' | 'structure' | 'code')[]
+  vector_types: ('semantic' | 'structure' | 'summary' | 'code')[]
   force_regenerate?: boolean
 }
 
@@ -109,6 +109,15 @@ async function generateEmbeddingBatch(inputs: string[]): Promise<string[]> {
   return sorted.map((d: any) => `[${d.embedding.join(',')}]`)
 }
 
+// Resolve platform account ID at runtime (slug: 'spine-system')
+let _platformAccountId: string | null = null
+async function getPlatformAccountId(): Promise<string | null> {
+  if (_platformAccountId) return _platformAccountId
+  const { data } = await adminDb.from('accounts').select('id').eq('slug', 'spine-system').maybeSingle()
+  _platformAccountId = data?.id ?? null
+  return _platformAccountId
+}
+
 // Insert an embedding record (used during batch writes)
 async function insertEmbedding(
   itemId: string,
@@ -116,12 +125,14 @@ async function insertEmbedding(
   chunkIndex: number,
   content: string,
   embedding: string,
-  metadata: any
+  metadata: any,
+  accountId?: string
 ): Promise<void> {
+  const resolvedAccountId = accountId ?? await getPlatformAccountId()
   await adminDb
     .from('embeddings')
     .insert({
-      account_id: '12acec9b-8451-40e7-80d5-e80c4e2fc0de', // Master account
+      account_id: resolvedAccountId,
       model_id: 'text-embedding-3-small',
       document_id: itemId,
       chunk_index: chunkIndex,
@@ -135,6 +146,33 @@ async function insertEmbedding(
     })
 }
 
+// Generate a one-paragraph AI summary for top-level retrieval matching
+async function generateArticleSummary(item: any): Promise<string> {
+  const apiKey = process.env.OPENAI_API_KEY || process.env.LLM_API_KEY
+  const baseUrl = process.env.OPENAI_BASE_URL || 'https://api.openai.com/v1'
+  if (!apiKey) return `${item.title || ''}: ${(item.description || '').slice(0, 300)}`
+
+  const plainText = (item.description || '')
+    .replace(/<[^>]+>/g, ' ').replace(/\s+/g, ' ').trim().slice(0, 3000)
+
+  const res = await fetch(`${baseUrl}/chat/completions`, {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json', Authorization: `Bearer ${apiKey}` },
+    body: JSON.stringify({
+      model: process.env.LLM_DEFAULT_MODEL || 'gpt-4o-mini',
+      temperature: 0.2,
+      max_tokens: 120,
+      messages: [
+        { role: 'system', content: 'Write a single concise paragraph (max 100 words) summarising this knowledge base article for search indexing. Output only the paragraph.' },
+        { role: 'user', content: `Title: ${item.title}\n\n${plainText}` }
+      ]
+    })
+  })
+  if (!res.ok) return `${item.title}: ${plainText.slice(0, 200)}`
+  const result: any = await res.json()
+  return result.choices?.[0]?.message?.content?.trim() || `${item.title}: ${plainText.slice(0, 200)}`
+}
+
 // Delete all existing embeddings for a document (called before re-embedding)
 async function deleteExistingEmbeddings(itemId: string): Promise<number> {
   const { data } = await adminDb
@@ -169,7 +207,8 @@ function isCodeChunk(item: any): boolean {
 async function handleGenerateEmbeddings(
   itemId: string,
   vectorTypes: string[],
-  forceRegenerate: boolean = false
+  forceRegenerate: boolean = false,
+  overrideAccountId?: string
 ): Promise<KBEmbeddingResponse> {
   const response: KBEmbeddingResponse = {
     success: true,
@@ -179,18 +218,20 @@ async function handleGenerateEmbeddings(
   }
 
   try {
-    // Get the KB item
+    // Get the KB item — allow any type when called from case resolution path
     const { data: item, error: itemError } = await adminDb
       .from('items')
       .select('*')
       .eq('id', itemId)
-      .eq('type_id', 'ce1e50b6-473e-4581-ba0c-e944f47cb240') // kb_article type
       .single()
 
     if (itemError || !item) {
-      throw new Error('KB item not found')
+      throw new Error('Item not found for embedding')
     }
 
+    // Resolve account: caller override > item's own account > platform account
+    const accountId = overrideAccountId || item.account_id || await getPlatformAccountId()
+
     // Check if embeddings already exist
     if (!forceRegenerate) {
       const { data: existing } = await adminDb
@@ -213,7 +254,7 @@ async function handleGenerateEmbeddings(
       response.embeddings_updated = deleted
     }
 
-    // ── Code chunks: legacy path (single semantic + single structure) ──
+    // ── Code chunks: legacy path (semantic + structure) ──
     if (isCodeChunk(item)) {
       const semanticContent = buildSemanticContent(item)
       const structureContent = buildStructureContent(item)
@@ -226,33 +267,32 @@ async function handleGenerateEmbeddings(
           chunk_id: item.data?.code_metadata?.chunk_id,
           chunk_type: item.data?.code_metadata?.chunk_type,
           file_path: item.data?.code_metadata?.file_path,
-        }),
+        }, accountId),
         insertEmbedding(itemId, 'structure', 0, structureContent, vectors[1], {
           kb_type: item.data?.kb_type,
           tags: item.data?.tags,
           file_path: item.data?.code_metadata?.file_path,
           depends_on: item.data?.code_metadata?.depends_on,
-        }),
+        }, accountId),
       ])
 
       response.embeddings_created = 2
       return response
     }
 
-    // ── Article path: chunk → batch embed → parallel write ──
+    // ── Article path: semantic chunks + structure + summary ──
     const articleContent = item.description || ''
-    const chunks = chunkArticle(articleContent, {
-      articleTitle: item.title || 'Untitled',
-    })
+    const chunks = chunkArticle(articleContent, { articleTitle: item.title || 'Untitled' })
 
-    // Build all texts to embed: N semantic chunks + 1 structure
     const structureContent = buildArticleStructureContent(item)
-    const allTexts = [...chunks.map(c => c.content), structureContent]
 
-    // Single batched API call to OpenAI
+    // Generate AI summary for top-level retrieval matching
+    const summaryContent = await generateArticleSummary(item)
+
+    // Single batched embed: N semantic chunks + 1 structure + 1 summary
+    const allTexts = [...chunks.map(c => c.content), structureContent, summaryContent]
     const allVectors = await generateEmbeddingBatch(allTexts)
 
-    // Parallel DB writes
     const writePromises: Promise<void>[] = []
 
     // Semantic embeddings — one per chunk
@@ -263,22 +303,32 @@ async function handleGenerateEmbeddings(
           chunk_index: i,
           chunk_total: chunks.length,
           section_path: chunks[i].sectionPath,
-        })
+          security_level: item.data?.security_level,
+        }, accountId)
       )
     }
 
-    // Structure embedding — article-level, single vector
+    // Structure embedding — facets for filtering
     writePromises.push(
       insertEmbedding(itemId, 'structure', 0, structureContent, allVectors[chunks.length], {
         kb_type: item.data?.kb_type,
         tags: item.data?.tags,
         category: item.data?.category,
         audience: item.data?.audience,
-      })
+        security_level: item.data?.security_level,
+      }, accountId)
+    )
+
+    // Summary embedding — one-paragraph AI summary for top-level matching
+    writePromises.push(
+      insertEmbedding(itemId, 'summary', 0, summaryContent, allVectors[chunks.length + 1], {
+        kb_type: item.data?.kb_type,
+        security_level: item.data?.security_level,
+      }, accountId)
     )
 
     await Promise.all(writePromises)
-    response.embeddings_created = chunks.length + 1
+    response.embeddings_created = chunks.length + 2 // +2 for structure + summary
 
   } catch (error) {
     response.success = false
@@ -288,6 +338,63 @@ async function handleGenerateEmbeddings(
   return response
 }
 
+/**
+ * Embeds a resolved ticket's case data as a knowledge source for future triage RAG.
+ * Called automatically when a ticket is resolved (via case analysis completion).
+ *
+ * Stores two vectors:
+ *   - 'semantic': ca_true_problem + ca_final_solution (the actual answer)
+ *   - 'summary': ca_reported_issue (how the customer described it — improves matching)
+ *
+ * These are stored with item_type: 'resolved_case' so they can be included in
+ * triage agent knowledge_sources without polluting the main KB article pool.
+ */
+export async function embedResolvedCase(ticketId: string, accountId: string): Promise<void> {
+  // Load ticket data fields
+  const { data: ticket } = await adminDb
+    .from('items')
+    .select('id, title, data')
+    .eq('id', ticketId)
+    .single()
+
+  if (!ticket) return
+
+  const trueProb = ticket.data?.ca_true_problem || ''
+  const finalSol = ticket.data?.ca_final_solution || ''
+  const reportedIssue = ticket.data?.ca_reported_issue || ticket.title || ''
+
+  if (!trueProb && !finalSol) return // nothing to embed
+
+  // Delete any pre-existing resolved_case embeddings for this ticket
+  await adminDb
+    .from('embeddings')
+    .delete()
+    .eq('document_id', ticketId)
+    .eq('metadata->>item_type', 'resolved_case')
+
+  const semanticContent = `Problem: ${trueProb}\n\nSolution: ${finalSol}`
+  const summaryContent = `Customer reported: ${reportedIssue}`
+
+  try {
+    const vectors = await generateEmbeddingBatch([semanticContent, summaryContent])
+    await Promise.all([
+      insertEmbedding(ticketId, 'semantic', 0, semanticContent, vectors[0], {
+        item_type: 'resolved_case',
+        security_level: 'internal',
+        kb_candidate: ticket.data?.ca_kb_candidate ?? false,
+        automation_potential: ticket.data?.ca_automation_potential ?? 'unknown',
+      }, accountId),
+      insertEmbedding(ticketId, 'summary', 0, summaryContent, vectors[1], {
+        item_type: 'resolved_case',
+        security_level: 'internal',
+      }, accountId),
+    ])
+  } catch (err) {
+    // Best-effort: don't fail ticket resolution if embedding fails
+    console.error(`embedResolvedCase failed for ticket ${ticketId}:`, err)
+  }
+}
+
 // Generate embedding vector for a query string via OpenAI
 async function generateQueryEmbedding(text: string): Promise<number[]> {
   const apiKey = process.env.OPENAI_API_KEY || process.env.LLM_API_KEY

package/functions/custom_support-redaction.ts

@@ -0,0 +1,115 @@
+import { createHandler } from './_shared/middleware'
+import { adminDb } from './_shared/db'
+import { resolveTypeId, resolveAgentId, resolvePromptConfigId } from './_shared/resolve-ids'
+import { runAgent } from './_shared/index'
+import { create } from './admin-data'
+
+/**
+ * @module custom_support-redaction
+ * @layer custom/cortex
+ * @stability custom
+ *
+ * KB Redaction Analysis — drives the RedactionReview page.
+ * Runs content through the KB Redaction Agent and returns structured
+ * redaction suggestions + a generalised rewrite ready for human review.
+ *
+ * Action: POST ?action=analyze
+ *   body: { ticket_id: string, content: string }
+ *
+ * Response: { analysis: RedactionAnalysis }
+ *   RedactionAnalysis matches the shape expected by RedactionReview.tsx:
+ *   {
+ *     original_content: string
+ *     redacted_content: string
+ *     suggestions: RedactionSuggestion[]
+ *     confidence_score: number
+ *     processing_metadata: { model_used, temperature, tokens_consumed }
+ *   }
+ *
+ * The agent message is saved in an internal analysis thread on the ticket
+ * (thread_purpose: 'redaction_analysis') as an audit trail.
+ */
+
+async function handleAnalyze(ctx: any, body: any) {
+  const { ticket_id, content } = body
+  if (!ticket_id) throw new Error('ticket_id is required')
+  if (!content) throw new Error('content is required')
+
+  const [threadTypeId, agentId, promptConfigId] = await Promise.all([
+    resolveTypeId('thread', 'thread'),
+    resolveAgentId('KB Redaction Agent'),
+    resolvePromptConfigId('kb_generator'),
+  ])
+
+  // Reuse existing redaction thread if one exists (idempotent re-analysis)
+  const { data: existing } = await adminDb
+    .from('threads')
+    .select('id')
+    .eq('target_type', 'items')
+    .eq('target_id', ticket_id)
+    .eq('visibility', 'internal')
+    .eq('data->>thread_purpose', 'redaction_analysis')
+    .maybeSingle()
+
+  let threadId = existing?.id
+
+  if (!threadId) {
+    const thread = await create(ctx, {
+      entity: 'threads',
+      type_id: threadTypeId,
+      target_type: 'items',
+      target_id: ticket_id,
+      visibility: 'internal',
+      status: 'active',
+      data: {
+        thread_purpose: 'redaction_analysis',
+        agent_id: agentId,
+        prompt_config_id: promptConfigId,
+      }
+    })
+    if (!thread?.id) throw new Error('Failed to create redaction thread')
+    threadId = thread.id
+  }
+
+  // Run the KB Redaction Agent — returns structured JSON in message content
+  const agentMsg = await runAgent(threadId, content, ctx)
+
+  // Parse JSON from agent response
+  let analysis: any = null
+  try {
+    const raw = agentMsg?.content || '{}'
+    const cleaned = raw.replace(/^```(?:json)?\s*/i, '').replace(/\s*```$/, '').trim()
+    analysis = JSON.parse(cleaned)
+  } catch {
+    // If the agent didn't return valid JSON, return a minimal analysis
+    // so the UI can still proceed with the original content unredacted
+    analysis = {
+      original_content: content,
+      redacted_content: content,
+      suggestions: [],
+      confidence_score: 0.0,
+      processing_metadata: {
+        model_used: 'unknown',
+        temperature: 0.1,
+        tokens_consumed: 0,
+        error: 'Agent response was not valid JSON',
+      }
+    }
+  }
+
+  // Ensure required fields are present for RedactionReview.tsx
+  if (!analysis.original_content) analysis.original_content = content
+  if (!analysis.suggestions) analysis.suggestions = []
+  if (typeof analysis.confidence_score !== 'number') analysis.confidence_score = 0.5
+  if (!analysis.processing_metadata) analysis.processing_metadata = { model_used: 'unknown', temperature: 0.1, tokens_consumed: 0 }
+
+  return { analysis, analysisThreadId: threadId }
+}
+
+export const handler = createHandler(async (ctx, body) => {
+  const action = (ctx as any).query?.action
+  switch (action) {
+    case 'analyze': return handleAnalyze(ctx, body)
+    default: throw new Error(`Unknown action: ${action}. Use 'analyze'.`)
+  }
+})

package/functions/custom_support-solution.ts

@@ -0,0 +1,104 @@
+import { createHandler } from './_shared/middleware'
+import { adminDb } from './_shared/db'
+import { resolveTypeId, resolveAgentId, resolvePromptConfigId } from './_shared/resolve-ids'
+import { runAgent } from './_shared/index'
+import { create } from './admin-data'
+
+/**
+ * @module custom_support-solution
+ * @layer custom/cortex
+ * @stability custom
+ *
+ * Solution AI — internal AI collaborator for support agents working a case.
+ * Powered by core's runAgent() with the 'solution_ai' prompt config.
+ * Never visible to the customer (all messages are visibility='internal').
+ *
+ * Two actions:
+ *   POST ?action=start   — ensures an internal AI thread exists for the ticket,
+ *                          sends the first message, returns thread + agent message.
+ *   POST ?action=message — sends a follow-up message on the existing AI thread.
+ *
+ * Response: { threadId, agentMessageId, content }
+ *
+ * The AI thread is distinct from the regular internal thread: it is tagged with
+ * data.thread_purpose = 'solution_ai' so the UI can find it deterministically.
+ */
+
+// ─── ACTION: START ─────────────────────────────────────────────────────────────
+
+async function handleStart(ctx: any, body: any) {
+  const { ticket_id, message } = body
+  if (!ticket_id) throw new Error('ticket_id is required')
+  if (!message) throw new Error('message is required')
+
+  const [threadTypeId, solutionAgentId, promptConfigId] = await Promise.all([
+    resolveTypeId('thread', 'thread'),
+    resolveAgentId('Solution AI Agent'),
+    resolvePromptConfigId('solution_ai'),
+  ])
+
+  // Find existing solution AI thread for this ticket
+  const { data: existing } = await adminDb
+    .from('threads')
+    .select('id')
+    .eq('target_type', 'items')
+    .eq('target_id', ticket_id)
+    .eq('visibility', 'internal')
+    .eq('data->>thread_purpose', 'solution_ai')
+    .maybeSingle()
+
+  let threadId = existing?.id
+
+  if (!threadId) {
+    const thread = await create(ctx, {
+      entity: 'threads',
+      type_id: threadTypeId,
+      target_type: 'items',
+      target_id: ticket_id,
+      visibility: 'internal',
+      status: 'active',
+      data: {
+        thread_purpose: 'solution_ai',
+        agent_id: solutionAgentId,
+        prompt_config_id: promptConfigId,
+      }
+    })
+    if (!thread?.id) throw new Error('Failed to create solution AI thread')
+    threadId = thread.id
+  }
+
+  const agentMsg = await runAgent(threadId, message, ctx)
+
+  return {
+    threadId,
+    agentMessageId: agentMsg?.id,
+    content: agentMsg?.content || '',
+  }
+}
+
+// ─── ACTION: MESSAGE ───────────────────────────────────────────────────────────
+
+async function handleMessage(ctx: any, body: any) {
+  const { thread_id, message } = body
+  if (!thread_id) throw new Error('thread_id is required')
+  if (!message) throw new Error('message is required')
+
+  const agentMsg = await runAgent(thread_id, message, ctx)
+
+  return {
+    threadId: thread_id,
+    agentMessageId: agentMsg?.id,
+    content: agentMsg?.content || '',
+  }
+}
+
+// ─── HANDLER ──────────────────────────────────────────────────────────────────
+
+export const handler = createHandler(async (ctx, body) => {
+  const action = (ctx as any).query?.action
+  switch (action) {
+    case 'start':   return handleStart(ctx, body)
+    case 'message': return handleMessage(ctx, body)
+    default: throw new Error(`Unknown action: ${action}. Use 'start' or 'message'.`)
+  }
+})

package/manifest.json

@@ -2,7 +2,7 @@
   "name": "Cortex",
   "slug": "cortex",
   "description": "Unified workspace for CRM, Support, Community, and Knowledge Base",
-  "version": "0.2.12",
+  "version": "0.2.22",
   "app_type": "full",
   "route_prefix": "/cortex",
   "required_roles": ["support", "support_admin"],
@@ -19,6 +19,7 @@
     "/crm/activity",
     "/support",
     "/support/:id",
+    "/support/:id/kb-review",
     "/community",
     "/kb",
     "/kb/editor",
@@ -90,10 +91,13 @@
   "entry_point": "./index.tsx",
   "sidebar_component": "./components/CortexSidebar.tsx",
   "seed": [
-    { "file": "seed/roles.json",            "table": "roles",      "conflict": "app_id,slug" },
-    { "file": "seed/types.json",            "table": "types",      "conflict": "app_id,kind,slug" },
-    { "file": "seed/link-types.json",       "table": "link_types", "conflict": "app_id,slug" },
-    { "file": "seed/type_permissions.json", "table": "types",      "conflict": "kind,slug", "inject_app_id": false, "permissions_patch": true }
+    { "file": "seed/roles.json",            "table": "roles",         "conflict": "app_id,slug" },
+    { "file": "seed/types.json",            "table": "types",         "conflict": "app_id,kind,slug" },
+    { "file": "seed/link-types.json",       "table": "link_types",    "conflict": "app_id,slug" },
+    { "file": "seed/ai-agents.json",        "table": "ai_agents",     "conflict": "app_id,name",    "inject_app_id": true },
+    { "file": "seed/prompt-configs.json",   "table": "prompt_configs","conflict": "app_id,slug",    "inject_app_id": true },
+    { "file": "seed/pipelines.json",        "table": "pipelines",     "conflict": "app_id,name",    "inject_app_id": true },
+    { "file": "seed/type_permissions.json", "table": "types",         "conflict": "kind,slug",      "inject_app_id": false, "permissions_patch": true }
   ],
   "registration": {
     "enabled": true,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "spine-framework-cortex",
-  "version": "0.2.21",
+  "version": "0.2.22",
   "private": false,
   "description": "Cortex — AI-powered support, CRM, and knowledge base app for Spine Framework",
   "keywords": [

package/pages/support/RedactionReview.tsx

@@ -39,13 +39,19 @@ interface Ticket {
   title: string
   description?: string
   data?: {
+    // Case analysis fields (populated by custom_case_analysis)
+    ca_reported_issue?: string
+    ca_true_problem?: string
+    ca_final_solution?: string
+    ca_diagnostic_steps?: string[]
+    ca_solution_steps?: string[]
+    // Legacy fields
     ai_metadata?: {
       problem_statement?: string
       solution_path?: string
     }
-    postmortem?: {
-      kb_draft_id?: string
-    }
+    // KB tracking
+    kb_proposed_kb_id?: string
   }
 }
 
@@ -118,12 +124,11 @@ export default function RedactionReview() {
           setArticleTitle(`KB: ${ticketData.title}`)
         }
 
-        // Trigger redaction analysis via AI agent
-        const analysisRes = await apiFetch('/api/ai-agents', {
+        // Trigger redaction analysis via KB Redaction Agent
+        const analysisRes = await apiFetch('/.netlify/functions/custom_support-redaction?action=analyze', {
           method: 'POST',
           headers: { 'Content-Type': 'application/json' },
           body: JSON.stringify({
-            action: 'run_redaction_analysis',
             ticket_id: id,
             content: buildContentForAnalysis(ticketData),
           }),
@@ -155,16 +160,33 @@ export default function RedactionReview() {
     })
   }, [id])
 
-  // Build content from ticket for analysis
+  // Build content from ticket for redaction analysis.
+  // Prefers case analysis fields (ca_*) populated by custom_case_analysis,
+  // falling back to legacy ai_metadata fields.
   function buildContentForAnalysis(ticket: Ticket): string {
+    const d = ticket.data || {}
     const parts: string[] = []
     if (ticket.title) parts.push(`Title: ${ticket.title}`)
-    if (ticket.description) parts.push(`Description: ${ticket.description}`)
-    if (ticket.data?.ai_metadata?.problem_statement) {
-      parts.push(`Problem: ${ticket.data.ai_metadata.problem_statement}`)
+    if (d.ca_reported_issue) {
+      parts.push(`Reported Issue: ${d.ca_reported_issue}`)
+    } else if (ticket.description) {
+      parts.push(`Description: ${ticket.description}`)
+    }
+    if (d.ca_true_problem) {
+      parts.push(`Root Cause: ${d.ca_true_problem}`)
+    } else if (d.ai_metadata?.problem_statement) {
+      parts.push(`Problem: ${d.ai_metadata.problem_statement}`)
+    }
+    if (d.ca_diagnostic_steps?.length) {
+      parts.push(`Diagnostic Steps:\n${d.ca_diagnostic_steps.map((s, i) => `${i + 1}. ${s}`).join('\n')}`)
     }
-    if (ticket.data?.ai_metadata?.solution_path) {
-      parts.push(`Solution: ${ticket.data.ai_metadata.solution_path}`)
+    if (d.ca_solution_steps?.length) {
+      parts.push(`Solution Steps:\n${d.ca_solution_steps.map((s, i) => `${i + 1}. ${s}`).join('\n')}`)
+    }
+    if (d.ca_final_solution) {
+      parts.push(`Final Solution: ${d.ca_final_solution}`)
+    } else if (d.ai_metadata?.solution_path) {
+      parts.push(`Solution: ${d.ai_metadata.solution_path}`)
     }
     return parts.join('\n\n')
   }
@@ -279,16 +301,12 @@ export default function RedactionReview() {
 
         // Update ticket with KB reference
         await apiFetch(`/api/admin-data?action=update&entity=items&id=${id}`, {
-          method: 'POST',
+          method: 'PATCH',
           headers: { 'Content-Type': 'application/json' },
           body: JSON.stringify({
             data: {
               ...ticket?.data,
-              postmortem: {
-                ...ticket?.data?.postmortem,
-                kb_generated: true,
-                kb_draft_id: kbId,
-              },
+              kb_proposed_kb_id: kbId,
             },
           }),
         })