spine-framework-cortex 0.2.24 → 0.2.26

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.26",
   "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.26",
   "private": false,
   "description": "Cortex — AI-powered support, CRM, and knowledge base app for Spine Framework",
   "keywords": [

package/pages/community/CommunityPage.tsx

@@ -1,7 +1,6 @@
 import { useState, useEffect } from 'react'
 import { Send, Hash, MessageSquarePlus, AlertCircle } from 'lucide-react'
 import { apiFetch } from '@core/lib/api'
-import { getTypeIdAsync } from '../../hooks/useTypeRegistry'
 import { Button } from '@core/components/ui/button'
 import { Input } from '@core/components/ui/input'
 import { Badge } from '@core/components/ui/badge'
@@ -21,15 +20,10 @@ function ThreadPane({ post }: { post: Post }) {
   const [loading, setLoading] = useState(true)
   const [replyText, setReplyText] = useState('')
   const [sending, setSending] = useState(false)
-  const [messageTypeId, setMessageTypeId] = useState<string | null>(null)
-
-  useEffect(() => {
-    getTypeIdAsync('message').then(id => setMessageTypeId(id))
-  }, [])
 
   useEffect(() => {
     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_slug=community_thread&limit=5`)
       .then(r => r.json()).then(j => {
         const t = (j?.data ?? j)?.[0] ?? null
         setThread(t)
@@ -39,12 +33,37 @@ function ThreadPane({ post }: { post: Post }) {
   }, [post.id])
 
   const handleSend = async () => {
-    if (!replyText.trim() || !thread || !messageTypeId) return
+    if (!replyText.trim()) 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_slug: 'community_thread',
+            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_slug: 'community_reply',
+          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
@@ -73,7 +92,7 @@ function ThreadPane({ post }: { post: Post }) {
       <div className="border-t p-3 flex gap-2 shrink-0">
         <Input placeholder="Reply as agent…" value={replyText} onChange={e => setReplyText(e.target.value)}
           onKeyDown={e => e.key === 'Enter' && !e.shiftKey && handleSend()} className="flex-1" />
-        <Button size="icon" onClick={handleSend} disabled={sending || !replyText.trim() || !thread || !messageTypeId}><Send size={14} /></Button>
+        <Button size="icon" onClick={handleSend} disabled={sending || !replyText.trim() || !thread}><Send size={14} /></Button>
       </div>
     </div>
   )

package/pages/courses/CoursesPage.tsx

@@ -1,7 +1,6 @@
-import { useState, useEffect, useRef } from 'react'
+import { useState, useEffect } from 'react'
 import { useNavigate } from 'react-router-dom'
 import { apiFetch } from '@core/lib/api'
-import { getTypeIdAsync } from '../../hooks/useTypeRegistry'
 import { Button } from '@core/components/ui/button'
 import { Input } from '@core/components/ui/input'
 import { Badge } from '@core/components/ui/badge'
@@ -31,13 +30,6 @@ function DiscussionPanel({ lesson }: { lesson: Lesson }) {
   const [loading, setLoading] = useState(true)
   const [newMessage, setNewMessage] = useState('')
   const [submitting, setSubmitting] = useState(false)
-  const messageTypeIdRef = useRef<string>('')
-
-  useEffect(() => {
-    getTypeIdAsync('message').then(id => {
-      if (id) messageTypeIdRef.current = id
-    })
-  }, [])
 
   useEffect(() => {
     setLoading(true)
@@ -53,10 +45,6 @@ function DiscussionPanel({ lesson }: { lesson: Lesson }) {
   const handleSubmit = async (e: React.FormEvent) => {
     e.preventDefault()
     if (!newMessage.trim() || submitting) return
-    if (!messageTypeIdRef.current) {
-      console.error('Message type not loaded')
-      return
-    }
 
     setSubmitting(true)
     try {
@@ -83,7 +71,7 @@ function DiscussionPanel({ lesson }: { lesson: Lesson }) {
         method: 'POST',
         headers: { 'Content-Type': 'application/json' },
         body: JSON.stringify({
-          type_id: messageTypeIdRef.current,
+          type_slug: 'message',
           thread_id: currentThread.id,
           content: newMessage.trim(),
           direction: 'inbound',

package/pages/kb/KBEditorPage.tsx

@@ -2,7 +2,6 @@ import { useState, useEffect } from 'react'
 import { useParams, useNavigate } from 'react-router-dom'
 import { useAppPath } from '@core/hooks/useAppPath'
 import { apiFetch } from '@core/lib/api'
-import { getTypeIdAsync } from '../../hooks/useTypeRegistry'
 import { RichTextEditor } from '@core/components/ui/RichTextEditor'
 import { Button } from '@core/components/ui/button'
 import { Input } from '@core/components/ui/input'
@@ -73,7 +72,6 @@ export default function KBEditorPage() {
   const [loading, setLoading] = useState(!isNew)
   const [saving, setSaving] = useState(false)
   const [error, setError] = useState<string | null>(null)
-  const [kbArticleTypeId, setKbArticleTypeId] = useState<string>('')
 
   useEffect(() => {
     if (isNew) return
@@ -97,23 +95,16 @@ export default function KBEditorPage() {
       .finally(() => setLoading(false))
   }, [id, isNew])
 
-  useEffect(() => {
-    getTypeIdAsync('kb_article').then(id => {
-      if (id) setKbArticleTypeId(id)
-    })
-  }, [])
-
   const handleSave = async (publish?: boolean) => {
     if (!form.title.trim()) { setError('Title is required'); return }
     if (!form.kb_type) { setError('KB Type is required'); return }
-    if (!kbArticleTypeId) { setError('Type not loaded'); return }
     setSaving(true)
     setError(null)
     try {
       const payload = {
         title: form.title.trim(),
         description: form.description,
-        type_id: kbArticleTypeId,
+        type_slug: 'kb_article',
         status: publish ? 'published' : form.status,
         data: {
           kb_type: form.kb_type,

package/pages/support/RedactionReview.tsx

@@ -2,7 +2,6 @@ import { useState, useEffect, useCallback } from 'react'
 import { useParams, useNavigate } from 'react-router-dom'
 import { useAppPath } from '@core/hooks/useAppPath'
 import { apiFetch } from '@core/lib/api'
-import { getTypeIdAsync } from '../../hooks/useTypeRegistry'
 import { Button } from '@core/components/ui/button'
 import { Badge } from '@core/components/ui/badge'
 import { ScrollArea } from '@core/components/ui/scroll-area'
@@ -107,7 +106,6 @@ export default function RedactionReview() {
   const [finalContent, setFinalContent] = useState('')
   const [articleTitle, setArticleTitle] = useState('')
   const [viewMode, setViewMode] = useState<'review' | 'final'>('review')
-  const [kbArticleTypeId, setKbArticleTypeId] = useState<string>('')
 
   // Load ticket and trigger redaction analysis
   useEffect(() => {
@@ -155,11 +153,6 @@ export default function RedactionReview() {
     }
 
     loadAndAnalyze()
-
-    // Load KB article type ID
-    getTypeIdAsync('kb_article').then(id => {
-      if (id) setKbArticleTypeId(id)
-    })
   }, [id])
 
   // Build content from ticket for redaction analysis.
@@ -264,10 +257,6 @@ export default function RedactionReview() {
   // Publish KB article
   const publishKB = async () => {
     if (!id || !finalContent || !articleTitle) return
-    if (!kbArticleTypeId) {
-      console.error('KB article type not loaded')
-      return
-    }
 
     setProcessing(true)
     try {
@@ -276,7 +265,7 @@ export default function RedactionReview() {
         method: 'POST',
         headers: { 'Content-Type': 'application/json' },
         body: JSON.stringify({
-          type_id: kbArticleTypeId,
+          type_slug: 'kb_article',
           title: articleTitle,
           status: 'published',
           description: finalContent,