spine-framework-cortex 0.2.24 → 0.2.25

package/functions/custom_tag_management.ts

@@ -0,0 +1,314 @@
+import { createHandler } from './_shared/middleware'
+import { adminDb } from './_shared/db'
+
+/**
+ * Custom Tag Management Handler
+ *
+ * Actions:
+ * - POST ?action=create_or_get_tag - Get existing tag or create new one
+ * - POST ?action=list_tags - List tags with filtering
+ * - POST ?action=update_tag_usage - Increment tag usage count
+ * - POST ?action=merge_tags - Merge duplicate tags
+ * 
+ * Provides centralized tag management for case analysis and other systems.
+ */
+
+// ─── CONSTANTS ────────────────────────────────────────────────────────────────
+
+const TAG_TYPE_ID = 'tag' // Will be looked up by slug
+
+// ─── TYPES ────────────────────────────────────────────────────────────────────
+
+interface TagRequest {
+  slug: string
+  name: string
+  purpose?: string
+  category: 'bug_classification' | 'knowledge_value' | 'process_type' | 'sentiment'
+  applicable_to?: string[]
+}
+
+interface TagResponse {
+  id: string
+  slug: string
+  name: string
+  purpose?: string
+  category: string
+  applicable_to: string[]
+  usage_count: number
+  created_at: string
+  updated_at: string
+}
+
+interface ListTagsRequest {
+  category?: string
+  applicable_to?: string
+  limit?: number
+  offset?: number
+}
+
+// ─── HELPERS ──────────────────────────────────────────────────────────────────
+
+async function getTagTypeId(): Promise<string> {
+  const { data: tagType } = await adminDb
+    .from('types')
+    .select('id')
+    .eq('slug', 'tag')
+    .single()
+  
+  if (!tagType) throw new Error('Tag type not found')
+  return tagType.id
+}
+
+async function findExistingTag(slug: string): Promise<TagResponse | null> {
+  const { data: tag } = await adminDb
+    .from('items')
+    .select('*')
+    .eq('type_id', await getTagTypeId())
+    .eq('data->>slug', slug)
+    .single()
+  
+  if (!tag) return null
+  
+  return {
+    id: tag.id,
+    slug: tag.data?.slug || '',
+    name: tag.title,
+    purpose: tag.description,
+    category: tag.data?.category || '',
+    applicable_to: tag.data?.applicable_to || ['ticket'],
+    usage_count: tag.data?.usage_count || 0,
+    created_at: tag.created_at,
+    updated_at: tag.updated_at
+  }
+}
+
+async function createTag(
+  tagData: TagRequest,
+  accountId: string
+): Promise<TagResponse> {
+  const tagTypeId = await getTagTypeId()
+  
+  const { data: tag, error } = await adminDb
+    .from('items')
+    .insert({
+      type_id: tagTypeId,
+      account_id: accountId,
+      title: tagData.name,
+      description: tagData.purpose,
+      data: {
+        slug: tagData.slug,
+        name: tagData.name,
+        purpose: tagData.purpose,
+        applicable_to: tagData.applicable_to || ['ticket'],
+        category: tagData.category,
+        usage_count: 1
+      },
+      status: 'active'
+    })
+    .select('*')
+    .single()
+  
+  if (error || !tag) throw new Error(`Failed to create tag: ${error?.message}`)
+  
+  return {
+    id: tag.id,
+    slug: tag.data?.slug || '',
+    name: tag.title,
+    purpose: tag.description,
+    category: tag.data?.category || '',
+    applicable_to: tag.data?.applicable_to || ['ticket'],
+    usage_count: tag.data?.usage_count || 0,
+    created_at: tag.created_at,
+    updated_at: tag.updated_at
+  }
+}
+
+async function incrementTagUsage(tagId: string): Promise<void> {
+  await adminDb
+    .from('items')
+    .update({
+      data: adminDb.sql`jsonb_set(data, '{usage_count}', COALESCE((data->>'usage_count')::int, 0) + 1)`,
+      updated_at: new Date().toISOString()
+    })
+    .eq('id', tagId)
+}
+
+// ─── ACTIONS ───────────────────────────────────────────────────────────────────
+
+async function handleCreateOrGetTag(
+  ctx: any,
+  body: TagRequest
+): Promise<TagResponse> {
+  const account_id = ctx.accountId as string
+  
+  if (!account_id) throw new Error('Account context required')
+  if (!body.slug || !body.name || !body.category) {
+    throw new Error('slug, name, and category are required')
+  }
+
+  // Validate slug format
+  if (!/^[a-z0-9_-]+$/.test(body.slug)) {
+    throw new Error('Slug must contain only lowercase letters, numbers, hyphens, and underscores')
+  }
+
+  // Try to find existing tag
+  const existingTag = await findExistingTag(body.slug)
+  
+  if (existingTag) {
+    // Increment usage count
+    await incrementTagUsage(existingTag.id)
+    
+    // Return updated tag with incremented count
+    const updatedTag = await findExistingTag(body.slug)
+    if (!updatedTag) throw new Error('Failed to retrieve updated tag')
+    
+    return updatedTag
+  }
+  
+  // Create new tag
+  return await createTag(body, account_id)
+}
+
+async function handleListTags(
+  ctx: any,
+  body: ListTagsRequest
+): Promise<{ tags: TagResponse[]; total: number }> {
+  const { category, applicable_to, limit = 50, offset = 0 } = body
+  const tagTypeId = await getTagTypeId()
+  
+  let query = adminDb
+    .from('items')
+    .select('*', { count: 'exact' })
+    .eq('type_id', tagTypeId)
+    .eq('status', 'active')
+    .order('data->>usage_count', { ascending: false })
+    .range(offset, offset + limit - 1)
+  
+  // Add filters
+  if (category) {
+    query = query.eq('data->>category', category)
+  }
+  
+  if (applicable_to) {
+    query = query.contains('data->>applicable_to', [applicable_to])
+  }
+  
+  const { data: tags, error, count } = await query
+  
+  if (error) throw new Error(`Failed to list tags: ${error?.message}`)
+  
+  const formattedTags: TagResponse[] = (tags || []).map(tag => ({
+    id: tag.id,
+    slug: tag.data?.slug || '',
+    name: tag.title,
+    purpose: tag.description,
+    category: tag.data?.category || '',
+    applicable_to: tag.data?.applicable_to || ['ticket'],
+    usage_count: tag.data?.usage_count || 0,
+    created_at: tag.created_at,
+    updated_at: tag.updated_at
+  }))
+  
+  return {
+    tags: formattedTags,
+    total: count || 0
+  }
+}
+
+async function handleUpdateTagUsage(
+  ctx: any,
+  body: { tag_id: string }
+): Promise<void> {
+  if (!body.tag_id) throw new Error('tag_id is required')
+  
+  await incrementTagUsage(body.tag_id)
+}
+
+async function handleMergeTags(
+  ctx: any,
+  body: { source_tag_id: string; target_tag_id: string }
+): Promise<{ merged_count: number }> {
+  const { source_tag_id, target_tag_id } = body
+  
+  if (!source_tag_id || !target_tag_id) {
+    throw new Error('source_tag_id and target_tag_id are required')
+  }
+  
+  if (source_tag_id === target_tag_id) {
+    throw new Error('Source and target tags cannot be the same')
+  }
+  
+  // Get source tag info
+  const { data: sourceTag } = await adminDb
+    .from('items')
+    .select('data')
+    .eq('id', source_tag_id)
+    .single()
+  
+  if (!sourceTag) throw new Error('Source tag not found')
+  
+  // Update all references to source tag to point to target tag
+  const sourceTagSlug = sourceTag.data?.slug
+  
+  // Update ticket analysis_tags arrays
+  const { data: ticketsToUpdate } = await adminDb
+    .from('items')
+    .select('id, data')
+    .eq('status', 'active')
+    .contains('data->>case_analysis->>analysis_tags', [source_tag_id])
+  
+  let mergedCount = 0
+  
+  for (const ticket of ticketsToUpdate || []) {
+    const caseAnalysis = ticket.data?.case_analysis || {}
+    const analysisTags = caseAnalysis.analysis_tags || []
+    
+    // Replace source tag with target tag
+    const updatedTags = analysisTags.map((tagId: string) => 
+      tagId === source_tag_id ? target_tag_id : tagId
+    )
+    
+    await adminDb
+      .from('items')
+      .update({
+        data: adminDb.sql`jsonb_set(data, '{case_analysis,analysis_tags}', ${updatedTags}::jsonb)`,
+        updated_at: new Date().toISOString()
+      })
+      .eq('id', ticket.id)
+    
+    mergedCount++
+  }
+  
+  // Increment target tag usage by source tag's usage count
+  const sourceUsage = sourceTag.data?.usage_count || 0
+  for (let i = 0; i < sourceUsage; i++) {
+    await incrementTagUsage(target_tag_id)
+  }
+  
+  // Delete source tag
+  await adminDb
+    .from('items')
+    .update({ status: 'deleted', updated_at: new Date().toISOString() })
+    .eq('id', source_tag_id)
+  
+  return { merged_count }
+}
+
+// ─── HANDLER ──────────────────────────────────────────────────────────────────
+
+export const handler = createHandler(async (ctx, body) => {
+  const action = ctx.query?.action
+
+  switch (action) {
+    case 'create_or_get_tag':
+      return await handleCreateOrGetTag(ctx, body)
+    case 'list_tags':
+      return await handleListTags(ctx, body)
+    case 'update_tag_usage':
+      return await handleUpdateTagUsage(ctx, body)
+    case 'merge_tags':
+      return await handleMergeTags(ctx, body)
+    default:
+      throw new Error(`Unknown action: ${action}. Use create_or_get_tag, list_tags, update_tag_usage, or merge_tags.`)
+  }
+})

package/manifest.json

@@ -2,7 +2,7 @@
   "name": "Cortex",
   "slug": "cortex",
   "description": "Unified workspace for CRM, Support, Community, and Knowledge Base",
-  "version": "0.2.22",
+  "version": "0.2.25",
   "app_type": "full",
   "route_prefix": "/cortex",
   "required_roles": ["support", "support_admin"],

package/package.json

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

package/pages/community/CommunityPage.tsx

@@ -21,30 +21,58 @@ function ThreadPane({ post }: { post: Post }) {
   const [loading, setLoading] = useState(true)
   const [replyText, setReplyText] = useState('')
   const [sending, setSending] = useState(false)
+  const [threadTypeId, setThreadTypeId] = useState<string | null>(null)
   const [messageTypeId, setMessageTypeId] = useState<string | null>(null)
 
   useEffect(() => {
-    getTypeIdAsync('message').then(id => setMessageTypeId(id))
+    getTypeIdAsync('community_thread').then(id => setThreadTypeId(id))
+    getTypeIdAsync('community_reply').then(id => setMessageTypeId(id))
   }, [])
 
   useEffect(() => {
+    if (!threadTypeId) return
     setLoading(true)
-    apiFetch(`/api/admin-data?action=list&entity=threads&target_id=${post.id}&limit=5`)
+    apiFetch(`/api/admin-data?action=list&entity=threads&target_id=${post.id}&type_id=${threadTypeId}&limit=5`)
       .then(r => r.json()).then(j => {
         const t = (j?.data ?? j)?.[0] ?? null
         setThread(t)
         if (t) return apiFetch(`/api/admin-data?action=list&entity=messages&thread_id=${t.id}&limit=100`).then(r => r.json())
         return []
       }).then(raw => { const msgs = raw?.data ?? raw; setMessages(Array.isArray(msgs) ? msgs : []) }).catch(() => {}).finally(() => setLoading(false))
-  }, [post.id])
+  }, [post.id, threadTypeId])
 
   const handleSend = async () => {
-    if (!replyText.trim() || !thread || !messageTypeId) return
+    if (!replyText.trim() || !messageTypeId || !threadTypeId) return
     setSending(true)
     try {
+      let activeThread = thread
+      if (!activeThread?.id) {
+        const res = await apiFetch('/api/admin-data?action=create&entity=threads', {
+          method: 'POST', headers: { 'Content-Type': 'application/json' },
+          body: JSON.stringify({
+            entity: 'threads',
+            type_id: threadTypeId,
+            target_type: 'items',
+            target_id: post.id,
+            status: 'open',
+          }),
+        })
+        const raw = await res.json()
+        activeThread = raw?.data ?? raw
+        if (activeThread?.id) setThread(activeThread)
+      }
+      if (!activeThread?.id) return
+
       const res = await apiFetch('/api/admin-data?action=create&entity=messages', {
         method: 'POST', headers: { 'Content-Type': 'application/json' },
-        body: JSON.stringify({ thread_id: thread.id, type_id: messageTypeId, content: replyText.trim(), direction: 'outbound', entity: 'messages' }),
+        body: JSON.stringify({
+          thread_id: activeThread.id,
+          type_id: messageTypeId,
+          content: replyText.trim(),
+          direction: 'outbound',
+          sequence: messages.reduce((max, m) => Math.max(max, m.sequence || 0), 0) + 1,
+          entity: 'messages',
+        }),
       })
       const raw = await res.json()
       const msg = raw?.data ?? raw

package/pages/support/TicketDetailPage.tsx

@@ -11,6 +11,7 @@ import { Tabs, TabsList, TabsTrigger, TabsContent } from '@core/components/ui/ta
 import { Textarea } from '@core/components/ui/textarea'
 import { ArrowLeft, Send, Lock, Globe, Bot, CheckCircle, AlertCircle, FileText, Building2, CreditCard, Package, BookOpen, Eye, EyeOff, Brain, Clock, TrendingUp, Tag as TagIcon, Sparkles } from 'lucide-react'
 import { useAuth } from '@core/contexts/AuthContext'
+import { getTypeIdAsync } from '../../hooks/useTypeRegistry'
 
 interface Ticket { 
   id: string; 
@@ -78,14 +79,18 @@ const STATUS_BADGE: Record<string, string> = {
 }
 
 // Merged Thread Panel - combines internal and external messages
-function MergedThreadPanel({ 
-  ticketId, 
-  externalThread, 
-  internalThread 
-}: { 
+function MergedThreadPanel({
+  ticketId,
+  externalThread,
+  internalThread,
+  threadTypeId,
+  messageTypeId,
+}: {
   ticketId: string
   externalThread: Thread | null
   internalThread: Thread | null
+  threadTypeId: string | null
+  messageTypeId: string | null
 }) {
   const [messages, setMessages] = useState<Message[]>([])
   const [loading, setLoading] = useState(true)
@@ -132,10 +137,8 @@ function MergedThreadPanel({
     try {
       // Create internal thread if it doesn't exist
       if (!targetThread && replyType === 'internal') {
-        const threadTypesRes = await apiFetch('/api/types?kind=thread&limit=1').then(r => r.json())
-        const threadTypes = Array.isArray(threadTypesRes?.data) ? threadTypesRes.data : Array.isArray(threadTypesRes) ? threadTypesRes : []
-        if (!threadTypes.length) {
-          console.error('No thread type found')
+        if (!threadTypeId) {
+          console.error('support_thread type not resolved')
           return
         }
 
@@ -145,29 +148,21 @@ function MergedThreadPanel({
             target_type: 'item',
             target_id: ticketId,
             visibility: 'internal',
-            type_id: threadTypes[0].id
+            type_id: threadTypeId
           }),
         })
         const newThread = await threadRes.json()
         if (newThread?.id) {
           targetThread = newThread
           // Refresh threads list
-          const thr = await apiFetch(`/api/admin-data?action=list&entity=threads&target_id=${ticketId}&limit=10`).then(r => r.json())
+          const thr = await apiFetch(`/api/admin-data?action=list&entity=threads&target_id=${ticketId}&type_id=${threadTypeId}&limit=10`).then(r => r.json())
           const threadList = thr?.data ?? thr
           setThreads(Array.isArray(threadList) ? threadList : [])
         }
       }
 
-      if (!targetThread) {
-        console.error('No thread available for message')
-        return
-      }
-
-      // Resolve message type_id
-      const typesRes = await apiFetch('/api/types?kind=message&limit=1').then(r => r.json())
-      const types = Array.isArray(typesRes?.data) ? typesRes.data : Array.isArray(typesRes) ? typesRes : []
-      if (!types.length) {
-        console.error('No message type found')
+      if (!targetThread || !messageTypeId) {
+        console.error('No thread or message type available for message')
         return
       }
 
@@ -178,11 +173,11 @@ function MergedThreadPanel({
 
       const res = await apiFetch('/api/admin-data?action=create&entity=messages', {
         method: 'POST', headers: { 'Content-Type': 'application/json' },
-        body: JSON.stringify({ 
-          thread_id: targetThread.id, 
-          content: reply.trim(), 
-          direction: 'outbound', 
-          type_id: types[0].id,
+        body: JSON.stringify({
+          thread_id: targetThread.id,
+          content: reply.trim(),
+          direction: 'outbound',
+          type_id: messageTypeId,
           sequence: nextSeq,
           visibility: replyType
         }),
@@ -739,18 +734,25 @@ export default function TicketDetailPage() {
   const [watcherId, setWatcherId] = useState<string | null>(null)
   const [watchLoading, setWatchLoading] = useState(false)
   const [analysisLoading, setAnalysisLoading] = useState(false)
+  const [threadTypeId, setThreadTypeId] = useState<string | null>(null)
+  const [messageTypeId, setMessageTypeId] = useState<string | null>(null)
+
+  useEffect(() => {
+    getTypeIdAsync('support_thread').then(id => setThreadTypeId(id))
+    getTypeIdAsync('support_reply').then(id => setMessageTypeId(id))
+  }, [])
 
   useEffect(() => {
-    if (!id) return
+    if (!id || !threadTypeId) return
     Promise.all([
       apiFetch(`/api/admin-data?action=get&entity=items&id=${id}`).then(r => r.json()),
-      apiFetch(`/api/admin-data?action=list&entity=threads&target_id=${id}&limit=10`).then(r => r.json()),
+      apiFetch(`/api/admin-data?action=list&entity=threads&target_id=${id}&type_id=${threadTypeId}&limit=10`).then(r => r.json()),
     ]).then(([ir, thr]) => {
       setTicket(ir?.data ?? ir ?? null)
       const threadList = thr?.data ?? thr
       setThreads(Array.isArray(threadList) ? threadList : [])
     }).catch(() => {}).finally(() => setLoading(false))
-  }, [id])
+  }, [id, threadTypeId])
 
   // Check if current user is watching this ticket
   useEffect(() => {
@@ -887,10 +889,12 @@ export default function TicketDetailPage() {
       <div className="flex flex-1 min-h-0">
         {/* Main Conversation Panel */}
         <div className="flex-1 min-w-0 border-r border-border">
-          <MergedThreadPanel 
-            ticketId={id || ''} 
-            externalThread={externalThread} 
-            internalThread={internalThread} 
+          <MergedThreadPanel
+            ticketId={id || ''}
+            externalThread={externalThread}
+            internalThread={internalThread}
+            threadTypeId={threadTypeId}
+            messageTypeId={messageTypeId}
           />
         </div>
 

package/seed/types.json

@@ -1868,7 +1868,7 @@
     "kind": "item",
     "slug": "course_lesson",
     "name": "Course Lesson",
-    "description": "Learning content unit — part of a course sequence",
+    "description": "Learning content unit \u2014 part of a course sequence",
     "icon": "graduation-cap",
     "color": "#F97316",
     "ownership": "tenant",
@@ -1986,4 +1986,4 @@
     },
     "validation_schema": {}
   }
-]
+]