@open-mercato/ai-assistant 0.4.2-canary-c02407ff85

package/src/frontend/hooks/useMcpTools.ts

@@ -0,0 +1,73 @@
+'use client'
+
+import { useState, useCallback, useEffect } from 'react'
+import type { ToolInfo, ToolExecutionResult } from '../types'
+
+export function useMcpTools() {
+  const [tools, setTools] = useState<ToolInfo[]>([])
+  const [isLoading, setIsLoading] = useState(false)
+  const [error, setError] = useState<string | null>(null)
+
+  const fetchTools = useCallback(async () => {
+    setIsLoading(true)
+    setError(null)
+    try {
+      const response = await fetch('/api/ai_assistant/tools')
+      if (!response.ok) {
+        throw new Error(`Failed to fetch tools: ${response.status}`)
+      }
+      const data = await response.json()
+      setTools(data.tools || [])
+    } catch (err) {
+      setError(err instanceof Error ? err.message : 'Failed to load tools')
+      setTools([])
+    } finally {
+      setIsLoading(false)
+    }
+  }, [])
+
+  const executeTool = useCallback(
+    async (toolName: string, args: Record<string, unknown> = {}): Promise<ToolExecutionResult> => {
+      try {
+        const response = await fetch('/api/ai_assistant/tools/execute', {
+          method: 'POST',
+          headers: { 'Content-Type': 'application/json' },
+          body: JSON.stringify({ toolName, args }),
+        })
+
+        const data = await response.json()
+
+        if (!response.ok) {
+          return {
+            success: false,
+            error: data.error || `Tool execution failed: ${response.status}`,
+          }
+        }
+
+        return {
+          success: true,
+          result: data.result,
+        }
+      } catch (err) {
+        return {
+          success: false,
+          error: err instanceof Error ? err.message : 'Tool execution failed',
+        }
+      }
+    },
+    []
+  )
+
+  // Fetch tools on mount
+  useEffect(() => {
+    fetchTools()
+  }, [fetchTools])
+
+  return {
+    tools,
+    isLoading,
+    error,
+    fetchTools,
+    executeTool,
+  }
+}

package/src/frontend/hooks/usePageContext.ts

@@ -0,0 +1,61 @@
+'use client'
+
+import { useMemo } from 'react'
+import { usePathname } from 'next/navigation'
+import type { PageContext } from '../types'
+
+interface UsePageContextOptions {
+  tenantId: string
+  organizationId: string | null
+}
+
+function extractModule(pathParts: string[]): string | null {
+  // Path structure: /backend/[module]/[entity]/[id]
+  // or /backend/[module]/[entity]
+  const backendIndex = pathParts.indexOf('backend')
+  if (backendIndex === -1 || backendIndex >= pathParts.length - 1) {
+    return null
+  }
+  return pathParts[backendIndex + 1] || null
+}
+
+function extractEntityType(pathParts: string[]): string | null {
+  const backendIndex = pathParts.indexOf('backend')
+  if (backendIndex === -1 || backendIndex >= pathParts.length - 2) {
+    return null
+  }
+  return pathParts[backendIndex + 2] || null
+}
+
+function extractRecordId(pathParts: string[]): string | null {
+  const backendIndex = pathParts.indexOf('backend')
+  if (backendIndex === -1 || backendIndex >= pathParts.length - 3) {
+    return null
+  }
+  const potentialId = pathParts[backendIndex + 3]
+  // Check if it looks like a UUID or ID
+  if (potentialId && /^[a-f0-9-]{36}$/i.test(potentialId)) {
+    return potentialId
+  }
+  return null
+}
+
+export function usePageContext(options: UsePageContextOptions): PageContext {
+  const pathname = usePathname()
+  const { tenantId, organizationId } = options
+
+  const pageContext = useMemo<PageContext>(() => {
+    const parts = pathname.split('/').filter(Boolean)
+
+    return {
+      path: pathname,
+      module: extractModule(parts),
+      entityType: extractEntityType(parts),
+      recordId: extractRecordId(parts),
+      tenantId,
+      organizationId,
+    }
+  }, [pathname, tenantId, organizationId])
+
+  return pageContext
+}

package/src/frontend/hooks/useRecentActions.ts

@@ -0,0 +1,64 @@
+'use client'
+
+import { useState, useCallback, useEffect } from 'react'
+import type { RecentAction } from '../types'
+import { RECENT_ACTIONS_KEY, MAX_RECENT_ACTIONS } from '../constants'
+
+function loadRecentActions(): RecentAction[] {
+  if (typeof window === 'undefined') return []
+  try {
+    const stored = localStorage.getItem(RECENT_ACTIONS_KEY)
+    if (!stored) return []
+    const parsed = JSON.parse(stored)
+    if (!Array.isArray(parsed)) return []
+    return parsed.slice(0, MAX_RECENT_ACTIONS)
+  } catch {
+    return []
+  }
+}
+
+function saveRecentActions(actions: RecentAction[]): void {
+  if (typeof window === 'undefined') return
+  try {
+    localStorage.setItem(RECENT_ACTIONS_KEY, JSON.stringify(actions.slice(0, MAX_RECENT_ACTIONS)))
+  } catch {
+    // Ignore localStorage errors
+  }
+}
+
+export function useRecentActions() {
+  const [recentActions, setRecentActions] = useState<RecentAction[]>([])
+
+  // Load from localStorage on mount
+  useEffect(() => {
+    setRecentActions(loadRecentActions())
+  }, [])
+
+  const addRecentAction = useCallback((action: Omit<RecentAction, 'id' | 'timestamp'>) => {
+    setRecentActions((prev) => {
+      const newAction: RecentAction = {
+        ...action,
+        id: crypto.randomUUID(),
+        timestamp: Date.now(),
+      }
+      // Remove duplicates by toolName, add new at start
+      const filtered = prev.filter((a) => a.toolName !== action.toolName)
+      const updated = [newAction, ...filtered].slice(0, MAX_RECENT_ACTIONS)
+      saveRecentActions(updated)
+      return updated
+    })
+  }, [])
+
+  const clearRecentActions = useCallback(() => {
+    setRecentActions([])
+    if (typeof window !== 'undefined') {
+      localStorage.removeItem(RECENT_ACTIONS_KEY)
+    }
+  }, [])
+
+  return {
+    recentActions,
+    addRecentAction,
+    clearRecentActions,
+  }
+}

package/src/frontend/hooks/useRecentTools.ts

@@ -0,0 +1,69 @@
+'use client'
+
+import { useState, useCallback, useEffect, useMemo } from 'react'
+import type { ToolInfo } from '../types'
+
+const RECENT_TOOLS_KEY = 'om:command-palette:recent-tools'
+const MAX_RECENT_TOOLS = 5
+
+function loadRecentToolIds(): string[] {
+  if (typeof window === 'undefined') return []
+  try {
+    const stored = localStorage.getItem(RECENT_TOOLS_KEY)
+    if (!stored) return []
+    const parsed = JSON.parse(stored)
+    if (!Array.isArray(parsed)) return []
+    return parsed.slice(0, MAX_RECENT_TOOLS)
+  } catch {
+    return []
+  }
+}
+
+function saveRecentToolIds(toolIds: string[]): void {
+  if (typeof window === 'undefined') return
+  try {
+    localStorage.setItem(RECENT_TOOLS_KEY, JSON.stringify(toolIds.slice(0, MAX_RECENT_TOOLS)))
+  } catch {
+    // Ignore localStorage errors
+  }
+}
+
+export function useRecentTools(allTools: ToolInfo[]) {
+  const [recentIds, setRecentIds] = useState<string[]>([])
+
+  // Load from localStorage on mount
+  useEffect(() => {
+    setRecentIds(loadRecentToolIds())
+  }, [])
+
+  const saveRecentTool = useCallback((toolName: string) => {
+    setRecentIds((prev) => {
+      // Add new tool at start, remove duplicates
+      const updated = [toolName, ...prev.filter((t) => t !== toolName)].slice(0, MAX_RECENT_TOOLS)
+      saveRecentToolIds(updated)
+      return updated
+    })
+  }, [])
+
+  const clearRecentTools = useCallback(() => {
+    setRecentIds([])
+    if (typeof window !== 'undefined') {
+      localStorage.removeItem(RECENT_TOOLS_KEY)
+    }
+  }, [])
+
+  // Map recent tool IDs to actual tool objects
+  const recentTools = useMemo(
+    () =>
+      recentIds
+        .map((id) => allTools.find((t) => t.name === id))
+        .filter((t): t is ToolInfo => t !== undefined),
+    [recentIds, allTools]
+  )
+
+  return {
+    recentTools,
+    saveRecentTool,
+    clearRecentTools,
+  }
+}

package/src/frontend/index.ts

@@ -0,0 +1,39 @@
+// Components
+export {
+  CommandPalette,
+  CommandPaletteProvider,
+  CommandPaletteWrapper,
+  useCommandPaletteContext,
+} from './components/CommandPalette'
+
+// Hooks
+export {
+  useCommandPalette,
+  useMcpTools,
+  usePageContext,
+  useRecentActions,
+} from './hooks'
+
+// Types
+export type {
+  CommandPaletteMode,
+  PageContext,
+  SelectedEntity,
+  ToolInfo,
+  ToolExecutionResult,
+  RecentAction,
+  ToolCall,
+  ChatMessage,
+  CommandPaletteState,
+  CommandPaletteContextValue,
+} from './types'
+
+// Utils
+export { filterTools, groupToolsByModule, humanizeToolName } from './utils'
+
+// Constants
+export {
+  COMMAND_PALETTE_SHORTCUT,
+  RECENT_ACTIONS_KEY,
+  MAX_RECENT_ACTIONS,
+} from './constants'

package/src/frontend/types.ts

@@ -0,0 +1,260 @@
+// Phase-based state for intelligent routing
+export type PalettePhase =
+  | 'idle'       // Empty, waiting for input
+  | 'routing'    // Fast model analyzing intent
+  | 'chatting'   // Smart model conversation for tool params
+  | 'confirming' // Waiting for user to approve tool call
+  | 'executing'  // Tool running
+
+// Page-based navigation for Raycast-style interface (deprecated, use PalettePhase)
+export type CommandPalettePage = 'home' | 'tool-chat'
+
+// Connection status for MCP servers
+export type ConnectionStatus = 'disconnected' | 'connecting' | 'connected' | 'error'
+
+// Legacy mode type (deprecated, kept for compatibility)
+export type CommandPaletteMode = 'commands' | 'chat'
+
+export interface PageContext {
+  path: string
+  module: string | null
+  entityType: string | null
+  recordId: string | null
+  tenantId: string
+  organizationId: string | null
+}
+
+export interface SelectedEntity {
+  entityType: string
+  recordId: string
+  displayName: string
+}
+
+export interface ToolInfo {
+  name: string
+  description: string
+  inputSchema: Record<string, unknown>
+  module?: string
+}
+
+export interface ToolExecutionResult {
+  success: boolean
+  result?: unknown
+  error?: string
+}
+
+export interface RecentAction {
+  id: string
+  toolName: string
+  displayName: string
+  timestamp: number
+  args?: Record<string, unknown>
+}
+
+// Tool call with confirmation support
+export interface ToolCall {
+  id: string
+  toolName: string
+  args: Record<string, unknown>
+  status: 'pending' | 'running' | 'completed' | 'error'
+  result?: unknown
+  error?: string
+}
+
+// Pending tool call awaiting user confirmation
+export interface PendingToolCall {
+  id: string
+  toolName: string
+  args: Record<string, unknown>
+  status: 'pending' | 'approved' | 'rejected' | 'executing' | 'completed' | 'error'
+  result?: unknown
+  error?: string
+}
+
+export interface ChatMessage {
+  id: string
+  role: 'user' | 'assistant' | 'system'
+  content: string
+  createdAt?: Date
+  // Tool call info if this message contains a tool call
+  toolCalls?: PendingToolCall[]
+}
+
+// New phase-based state for intelligent routing
+export interface CommandPaletteState {
+  isOpen: boolean
+  phase: PalettePhase
+  inputValue: string
+  selectedIndex: number
+  isLoading: boolean
+  isStreaming: boolean
+  connectionStatus: ConnectionStatus
+  // Legacy fields for backwards compatibility
+  page: CommandPalettePage
+  mode: CommandPaletteMode
+}
+
+export interface CommandPaletteContextValue {
+  state: CommandPaletteState
+  isThinking: boolean
+  isSessionAuthorized: boolean
+  pageContext: PageContext | null
+  selectedEntities: SelectedEntity[]
+  tools: ToolInfo[]
+  filteredTools: ToolInfo[]
+  recentActions: RecentAction[]
+  recentTools: ToolInfo[]
+  messages: ChatMessage[]
+  pendingToolCalls: PendingToolCall[]
+  selectedTool: ToolInfo | null
+  initialContext: {
+    tenantId: string | null
+    organizationId: string | null
+    userId: string
+    isSuperAdmin: boolean
+    features: string[]
+  } | null
+  availableEntities: Array<{ entityId: string; enabled: boolean }> | null
+
+  // Navigation actions
+  open: () => void
+  close: () => void
+  setInputValue: (value: string) => void
+  setSelectedIndex: (index: number) => void
+
+  // Intelligent routing - submit natural language query
+  handleSubmit: (query: string) => Promise<void>
+  reset: () => void
+
+  // Page navigation (legacy, kept for compatibility)
+  goToToolChat: (tool: ToolInfo) => void
+  goBack: () => void
+
+  // Tool execution
+  executeTool: (toolName: string, args?: Record<string, unknown>) => Promise<ToolExecutionResult>
+  approveToolCall: (toolCallId: string) => Promise<void>
+  rejectToolCall: (toolCallId: string) => void
+
+  // Chat actions
+  sendMessage: (content: string) => Promise<void>
+  sendAgenticMessage: (content: string) => Promise<void>
+  clearMessages: () => void
+
+  // Legacy compatibility
+  setMode: (mode: CommandPaletteMode) => void
+  setIsOpen: (isOpen: boolean) => void
+
+  // Debug mode
+  debugEvents: DebugEvent[]
+  showDebug: boolean
+  setShowDebug: (show: boolean) => void
+  clearDebugEvents: () => void
+
+  // OpenCode question handling
+  pendingQuestion: OpenCodeQuestion | null
+  answerQuestion: (answer: number) => Promise<void>
+}
+
+export interface ChatApiRequest {
+  messages: ChatMessage[]
+  context: PageContext | null
+  mode?: 'default' | 'tool-assist' | 'tool-assist-confirm'
+  toolName?: string // For tool-specific chat sessions
+}
+
+// Routing API response
+export interface RouteResult {
+  intent: 'tool' | 'general_chat'
+  toolName?: string
+  confidence: number
+  reasoning: string
+}
+
+export interface ToolsApiResponse {
+  tools: ToolInfo[]
+}
+
+export interface ToolExecuteRequest {
+  toolName: string
+  args: Record<string, unknown>
+}
+
+export interface ToolExecuteResponse {
+  success: boolean
+  result?: unknown
+  error?: string
+}
+
+// Stream event types for tool-assist-confirm mode
+export type StreamEventType = 'text' | 'tool-call' | 'tool-result' | 'error' | 'done'
+
+export interface StreamEvent {
+  type: StreamEventType
+  content?: string
+  toolCall?: {
+    id: string
+    toolName: string
+    args: Record<string, unknown>
+  }
+  toolResult?: {
+    id: string
+    result: unknown
+  }
+  error?: string
+}
+
+// Debug event types for debugging the AI chat
+export type DebugEventType =
+  | 'thinking'
+  | 'tool-call'
+  | 'tool-result'
+  | 'text'
+  | 'error'
+  | 'done'
+  | 'message'
+  | 'connection'
+  | 'metadata'
+  | 'debug'
+  | 'question'
+  | 'session-authorized'
+
+export interface DebugEvent {
+  id: string
+  timestamp: Date
+  type: DebugEventType
+  data: unknown
+}
+
+// Question option from OpenCode
+export interface OpenCodeQuestionOption {
+  label: string
+  description: string
+}
+
+// Question from OpenCode requiring user confirmation
+export interface OpenCodeQuestion {
+  id: string
+  sessionID: string
+  questions: Array<{
+    question: string
+    header: string
+    options: OpenCodeQuestionOption[]
+  }>
+  tool: {
+    messageID: string
+    callID: string
+  }
+}
+
+// SSE event types from chat API (OpenCode integration)
+export type ChatSSEEvent =
+  | { type: 'thinking' }
+  | { type: 'text'; content: string }
+  | { type: 'tool-call'; id: string; toolName: string; args: unknown }
+  | { type: 'tool-result'; id: string; result: unknown }
+  | { type: 'question'; question: OpenCodeQuestion }
+  | { type: 'metadata'; model?: string; provider?: string; tokens?: { input: number; output: number }; timing?: { created: number; completed?: number }; durationMs?: number }
+  | { type: 'debug'; partType: string; data: unknown }
+  | { type: 'done'; sessionId?: string }
+  | { type: 'error'; error: string }
+  | { type: 'session-authorized'; sessionToken?: string }

package/src/frontend/utils/index.ts

@@ -0,0 +1 @@
+export { filterTools, groupToolsByModule, humanizeToolName } from './toolMatcher'

package/src/frontend/utils/toolMatcher.ts

@@ -0,0 +1,127 @@
+import type { ToolInfo } from '../types'
+
+function normalizeString(str: string): string {
+  return str.toLowerCase().replace(/[._-]/g, ' ')
+}
+
+function fuzzyMatch(query: string, target: string): boolean {
+  const normalizedQuery = normalizeString(query)
+  const normalizedTarget = normalizeString(target)
+
+  // Check if all query chars appear in order in target
+  let queryIndex = 0
+  for (let i = 0; i < normalizedTarget.length && queryIndex < normalizedQuery.length; i++) {
+    if (normalizedTarget[i] === normalizedQuery[queryIndex]) {
+      queryIndex++
+    }
+  }
+  return queryIndex === normalizedQuery.length
+}
+
+function scoreMatch(query: string, tool: ToolInfo): number {
+  const normalizedQuery = normalizeString(query)
+  const normalizedName = normalizeString(tool.name)
+  const normalizedDesc = normalizeString(tool.description)
+
+  let score = 0
+
+  // Exact match in name = highest score
+  if (normalizedName.includes(normalizedQuery)) {
+    score += 100
+  }
+
+  // Starts with query
+  if (normalizedName.startsWith(normalizedQuery)) {
+    score += 50
+  }
+
+  // Word boundary match
+  const nameWords = normalizedName.split(' ')
+  if (nameWords.some((word) => word.startsWith(normalizedQuery))) {
+    score += 30
+  }
+
+  // Fuzzy match in name
+  if (fuzzyMatch(normalizedQuery, normalizedName)) {
+    score += 20
+  }
+
+  // Match in description
+  if (normalizedDesc.includes(normalizedQuery)) {
+    score += 10
+  }
+
+  return score
+}
+
+export function filterTools(tools: ToolInfo[], query: string): ToolInfo[] {
+  if (!query.trim()) {
+    return tools
+  }
+
+  const normalizedQuery = query.trim().toLowerCase()
+
+  // Score and filter tools
+  const scoredTools = tools
+    .map((tool) => ({
+      tool,
+      score: scoreMatch(normalizedQuery, tool),
+    }))
+    .filter(({ score }) => score > 0)
+    .sort((a, b) => b.score - a.score)
+
+  return scoredTools.map(({ tool }) => tool)
+}
+
+export function groupToolsByModule(tools: ToolInfo[]): Map<string, ToolInfo[]> {
+  const grouped = new Map<string, ToolInfo[]>()
+
+  for (const tool of tools) {
+    const module = tool.module || extractModuleFromName(tool.name)
+    const existing = grouped.get(module) || []
+    existing.push(tool)
+    grouped.set(module, existing)
+  }
+
+  return grouped
+}
+
+function extractModuleFromName(name: string): string {
+  const parts = name.split('.')
+  return parts[0] || 'other'
+}
+
+export function humanizeToolName(name: string): string {
+  // customers.people.create -> Create Person
+  const parts = name.split('.')
+  if (parts.length < 2) return name
+
+  const action = parts[parts.length - 1]
+  const resource = parts[parts.length - 2]
+
+  const humanAction = capitalize(action)
+  const humanResource = singularize(humanize(resource))
+
+  return `${humanAction} ${humanResource}`
+}
+
+function capitalize(str: string): string {
+  return str.charAt(0).toUpperCase() + str.slice(1)
+}
+
+function humanize(str: string): string {
+  return str.replace(/[_-]/g, ' ').replace(/([a-z])([A-Z])/g, '$1 $2')
+}
+
+function singularize(str: string): string {
+  if (str.endsWith('ies')) {
+    return str.slice(0, -3) + 'y'
+  }
+  if (str.endsWith('es') && !str.endsWith('ses')) {
+    return str.slice(0, -2)
+  }
+  if (str.endsWith('s') && !str.endsWith('ss')) {
+    return str.slice(0, -1)
+  }
+  return str
+}